From f3d0a84a06bace7bfcf5f98b30f93bf77edf8144 Mon Sep 17 00:00:00 2001 From: clca Date: Mon, 5 Nov 2012 22:23:33 -0800 Subject: [PATCH 001/782] Reactive Extensions OSS V1.0 --- Ix++/.gitignore | 109 + Ix++/license.txt.txt | 15 + Ix++/projects/CppLinq.vpj | 156 ++ Ix++/projects/CppLinq.vpw | 7 + Ix++/projects/Unittest.CppLinq.vpj | 137 + Ix++/samples/SampleCppLinq/SampleCppLinq.cpp | 128 + Ix++/samples/SampleCppLinq/SampleCppLinq.sln | 20 + .../SampleCppLinq/SampleCppLinq.vcxproj | 92 + .../SampleCppLinq.vcxproj.filters | 25 + Ix++/samples/SampleCppLinq/data.txt | 655 +++++ Ix++/src/cpplinq/linq.hpp | 531 ++++ Ix++/src/cpplinq/linq_cursor.hpp | 340 +++ Ix++/src/cpplinq/linq_groupby.hpp | 195 ++ Ix++/src/cpplinq/linq_iterators.hpp | 194 ++ Ix++/src/cpplinq/linq_last.hpp | 85 + Ix++/src/cpplinq/linq_select.hpp | 52 + Ix++/src/cpplinq/linq_selectmany.hpp | 107 + Ix++/src/cpplinq/linq_skip.hpp | 35 + Ix++/src/cpplinq/linq_take.hpp | 96 + Ix++/src/cpplinq/linq_where.hpp | 69 + Ix++/src/cpplinq/util.hpp | 223 ++ Ix++/unittest/makefile | 37 + Ix++/unittest/testbench.cpp | 527 ++++ Ix++/unittest/testbench.hpp | 87 + Ix/.gitattributes | 22 + Ix/.gitignore | 163 ++ Ix/Common.targets | 180 ++ Ix/Import.targets | 16 + Ix/Interactive Extensions.sln | 332 +++ Ix/Interactive Extensions.vsmdi | 6 + Ix/Interactive Extensions.vssscc | 10 + Ix/Local.testsettings | 37 + .../AsyncEnumerable.Aggregates.cs | 2019 ++++++++++++++ .../AsyncEnumerable.Conversions.cs | 262 ++ .../AsyncEnumerable.Creation.cs | 283 ++ .../AsyncEnumerable.Exceptions.cs | 381 +++ .../AsyncEnumerable.Generated.cs | 1250 +++++++++ .../AsyncEnumerable.Multiple.cs | 755 +++++ .../AsyncEnumerable.Single.cs | 2466 +++++++++++++++++ .../AsyncEnumerator.cs | 26 + Ix/System.Interactive.Async/Disposables.cs | 89 + .../EnumerableGrouping.cs | 34 + .../IAsyncEnumerable.cs | 23 + .../IAsyncEnumerator.cs | 34 + Ix/System.Interactive.Async/IAsyncGrouping.cs | 19 + .../IOrderedAsyncEnumerable.cs | 15 + .../Properties/AssemblyInfo.cs | 37 + .../System.Interactive.Async.csproj | 47 + Ix/System.Interactive.Async/TaskExt.cs | 134 + .../Properties/AssemblyInfo.cs | 37 + .../QueryableEx.cs | 2327 ++++++++++++++++ .../System.Interactive.Providers.csproj | 41 + .../EnumerableEx.Aggregates.cs | 173 ++ .../EnumerableEx.Buffering.cs | 647 +++++ .../EnumerableEx.Creation.cs | 173 ++ .../EnumerableEx.Exceptions.cs | 284 ++ .../EnumerableEx.Imperative.cs | 156 ++ .../EnumerableEx.Multiple.cs | 96 + Ix/System.Interactive/EnumerableEx.Single.cs | 672 +++++ .../Properties/AssemblyInfo.cs | 37 + .../System.Interactive.csproj | 41 + Ix/Tests/App.cs | 47 + Ix/Tests/AsyncTests.Aggregates.cs | 2168 +++++++++++++++ Ix/Tests/AsyncTests.Bugs.cs | 266 ++ Ix/Tests/AsyncTests.Conversions.cs | 312 +++ Ix/Tests/AsyncTests.Creation.cs | 409 +++ Ix/Tests/AsyncTests.Exceptions.cs | 551 ++++ Ix/Tests/AsyncTests.Multiple.cs | 787 ++++++ Ix/Tests/AsyncTests.Single.cs | 2455 ++++++++++++++++ Ix/Tests/AsyncTests.cs | 54 + Ix/Tests/Properties/AppManifest.xml | 7 + Ix/Tests/Properties/AssemblyInfo.cs | 35 + Ix/Tests/Tests.Aggregates.cs | 118 + Ix/Tests/Tests.Buffering.cs | 625 +++++ Ix/Tests/Tests.Creation.cs | 224 ++ Ix/Tests/Tests.Exceptions.cs | 311 +++ Ix/Tests/Tests.Imperative.cs | 180 ++ Ix/Tests/Tests.Multiple.cs | 74 + Ix/Tests/Tests.Qbservable.cs | 139 + Ix/Tests/Tests.Single.cs | 431 +++ Ix/Tests/Tests.cs | 51 + Ix/Tests/Tests.csproj | 91 + Ix/TraceAndTestImpact.testsettings | 21 + Ix/license.txt | 15 + README.md | 24 + Rx++/.gitattributes | 22 + Rx++/.gitignore | 163 ++ Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 171 ++ Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h | 91 + .../MfcTimeFliesLikeAnArrow.cpp | 153 + .../MfcTimeFliesLikeAnArrow.h | 37 + .../MfcTimeFliesLikeAnArrow.rc | 276 ++ .../MfcTimeFliesLikeAnArrow.vcxproj | 137 + .../MfcTimeFliesLikeAnArrow.vcxproj.filters | 63 + Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt | 95 + Rx++/MfcTimeFliesLikeAnArrow/Resource.h | 20 + .../res/MfcTimeFliesLikeAnArrow.ico | Bin 0 -> 67777 bytes .../res/MfcTimeFliesLikeAnArrow.rc2 | Bin 0 -> 830 bytes Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp | 9 + Rx++/MfcTimeFliesLikeAnArrow/stdafx.h | 64 + Rx++/MfcTimeFliesLikeAnArrow/targetver.h | 10 + Rx++/RxCpp.sln | 26 + Rx++/license.txt | 15 + Rx++/testbench/rxcpp-binder.h | 48 + Rx++/testbench/rxcpp.h | 889 ++++++ Rx++/testbench/testbench.cpp | 45 + Rx++/testbench/testbench.vcxproj | 95 + Rx++/testbench/testbench.vcxproj.filters | 30 + 108 files changed, 29100 insertions(+) create mode 100644 Ix++/.gitignore create mode 100644 Ix++/license.txt.txt create mode 100644 Ix++/projects/CppLinq.vpj create mode 100644 Ix++/projects/CppLinq.vpw create mode 100644 Ix++/projects/Unittest.CppLinq.vpj create mode 100644 Ix++/samples/SampleCppLinq/SampleCppLinq.cpp create mode 100644 Ix++/samples/SampleCppLinq/SampleCppLinq.sln create mode 100644 Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj create mode 100644 Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters create mode 100644 Ix++/samples/SampleCppLinq/data.txt create mode 100644 Ix++/src/cpplinq/linq.hpp create mode 100644 Ix++/src/cpplinq/linq_cursor.hpp create mode 100644 Ix++/src/cpplinq/linq_groupby.hpp create mode 100644 Ix++/src/cpplinq/linq_iterators.hpp create mode 100644 Ix++/src/cpplinq/linq_last.hpp create mode 100644 Ix++/src/cpplinq/linq_select.hpp create mode 100644 Ix++/src/cpplinq/linq_selectmany.hpp create mode 100644 Ix++/src/cpplinq/linq_skip.hpp create mode 100644 Ix++/src/cpplinq/linq_take.hpp create mode 100644 Ix++/src/cpplinq/linq_where.hpp create mode 100644 Ix++/src/cpplinq/util.hpp create mode 100644 Ix++/unittest/makefile create mode 100644 Ix++/unittest/testbench.cpp create mode 100644 Ix++/unittest/testbench.hpp create mode 100644 Ix/.gitattributes create mode 100644 Ix/.gitignore create mode 100644 Ix/Common.targets create mode 100644 Ix/Import.targets create mode 100644 Ix/Interactive Extensions.sln create mode 100644 Ix/Interactive Extensions.vsmdi create mode 100644 Ix/Interactive Extensions.vssscc create mode 100644 Ix/Local.testsettings create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Single.cs create mode 100644 Ix/System.Interactive.Async/AsyncEnumerator.cs create mode 100644 Ix/System.Interactive.Async/Disposables.cs create mode 100644 Ix/System.Interactive.Async/EnumerableGrouping.cs create mode 100644 Ix/System.Interactive.Async/IAsyncEnumerable.cs create mode 100644 Ix/System.Interactive.Async/IAsyncEnumerator.cs create mode 100644 Ix/System.Interactive.Async/IAsyncGrouping.cs create mode 100644 Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs create mode 100644 Ix/System.Interactive.Async/Properties/AssemblyInfo.cs create mode 100644 Ix/System.Interactive.Async/System.Interactive.Async.csproj create mode 100644 Ix/System.Interactive.Async/TaskExt.cs create mode 100644 Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs create mode 100644 Ix/System.Interactive.Providers/QueryableEx.cs create mode 100644 Ix/System.Interactive.Providers/System.Interactive.Providers.csproj create mode 100644 Ix/System.Interactive/EnumerableEx.Aggregates.cs create mode 100644 Ix/System.Interactive/EnumerableEx.Buffering.cs create mode 100644 Ix/System.Interactive/EnumerableEx.Creation.cs create mode 100644 Ix/System.Interactive/EnumerableEx.Exceptions.cs create mode 100644 Ix/System.Interactive/EnumerableEx.Imperative.cs create mode 100644 Ix/System.Interactive/EnumerableEx.Multiple.cs create mode 100644 Ix/System.Interactive/EnumerableEx.Single.cs create mode 100644 Ix/System.Interactive/Properties/AssemblyInfo.cs create mode 100644 Ix/System.Interactive/System.Interactive.csproj create mode 100644 Ix/Tests/App.cs create mode 100644 Ix/Tests/AsyncTests.Aggregates.cs create mode 100644 Ix/Tests/AsyncTests.Bugs.cs create mode 100644 Ix/Tests/AsyncTests.Conversions.cs create mode 100644 Ix/Tests/AsyncTests.Creation.cs create mode 100644 Ix/Tests/AsyncTests.Exceptions.cs create mode 100644 Ix/Tests/AsyncTests.Multiple.cs create mode 100644 Ix/Tests/AsyncTests.Single.cs create mode 100644 Ix/Tests/AsyncTests.cs create mode 100644 Ix/Tests/Properties/AppManifest.xml create mode 100644 Ix/Tests/Properties/AssemblyInfo.cs create mode 100644 Ix/Tests/Tests.Aggregates.cs create mode 100644 Ix/Tests/Tests.Buffering.cs create mode 100644 Ix/Tests/Tests.Creation.cs create mode 100644 Ix/Tests/Tests.Exceptions.cs create mode 100644 Ix/Tests/Tests.Imperative.cs create mode 100644 Ix/Tests/Tests.Multiple.cs create mode 100644 Ix/Tests/Tests.Qbservable.cs create mode 100644 Ix/Tests/Tests.Single.cs create mode 100644 Ix/Tests/Tests.cs create mode 100644 Ix/Tests/Tests.csproj create mode 100644 Ix/TraceAndTestImpact.testsettings create mode 100644 Ix/license.txt create mode 100644 README.md create mode 100644 Rx++/.gitattributes create mode 100644 Rx++/.gitignore create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/Resource.h create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/stdafx.h create mode 100644 Rx++/MfcTimeFliesLikeAnArrow/targetver.h create mode 100644 Rx++/RxCpp.sln create mode 100644 Rx++/license.txt create mode 100644 Rx++/testbench/rxcpp-binder.h create mode 100644 Rx++/testbench/rxcpp.h create mode 100644 Rx++/testbench/testbench.cpp create mode 100644 Rx++/testbench/testbench.vcxproj create mode 100644 Rx++/testbench/testbench.vcxproj.filters diff --git a/Ix++/.gitignore b/Ix++/.gitignore new file mode 100644 index 0000000..8bbd318 --- /dev/null +++ b/Ix++/.gitignore @@ -0,0 +1,109 @@ +# Custom +*.vtg +*.vpwhist + +# Build Folders (you can keep bin if you'd like, to store dlls and pdbs) +[Bb]in/ +[Oo]bj/ + +# mstest test results +TestResults + +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.sln.docstates + +# Build results +[Dd]ebug/ +[Rr]elease/ +x64/ +*_i.c +*_p.c +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.log +*.vspscc +*.vssscc +.builds + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf + +# Visual Studio profiler +*.psess +*.vsp +*.vspx + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper* + +# NCrunch +*.ncrunch* +.*crunch*.local.xml + +# Installshield output folder +[Ee]xpress + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish + +# Publish Web Output +*.Publish.xml + +# NuGet Packages Directory +packages + +# Windows Azure Build Output +csx +*.build.csdef + +# Others +[Bb]in +[Oo]bj +sql +TestResults +[Tt]est[Rr]esult* +*.Cache +ClientBin +[Ss]tyle[Cc]op.* +~$* +*.dbmdl +Generated_Code #added for RIA/Silverlight projects + +# Backup & report files from converting an old project file to a newer +# Visual Studio version. Backup files are not needed, because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML \ No newline at end of file diff --git a/Ix++/license.txt.txt b/Ix++/license.txt.txt new file mode 100644 index 0000000..d7fd6c0 --- /dev/null +++ b/Ix++/license.txt.txt @@ -0,0 +1,15 @@ +Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +Microsoft Open Technologies would like to thank its contributors, a list +of whom are at http://aspnetwebstack.codeplex.com/wikipage?title=Contributors. + +Licensed under the Apache License, Version 2.0 (the "License"); you +may not use this file except in compliance with the License. You may +obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied. See the License for the specific language governing permissions +and limitations under the License. \ No newline at end of file diff --git a/Ix++/projects/CppLinq.vpj b/Ix++/projects/CppLinq.vpj new file mode 100644 index 0000000..209f42c --- /dev/null +++ b/Ix++/projects/CppLinq.vpj @@ -0,0 +1,156 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Ix++/projects/CppLinq.vpw b/Ix++/projects/CppLinq.vpw new file mode 100644 index 0000000..105f982 --- /dev/null +++ b/Ix++/projects/CppLinq.vpw @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Ix++/projects/Unittest.CppLinq.vpj b/Ix++/projects/Unittest.CppLinq.vpj new file mode 100644 index 0000000..7bbb967 --- /dev/null +++ b/Ix++/projects/Unittest.CppLinq.vpj @@ -0,0 +1,137 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.cpp b/Ix++/samples/SampleCppLinq/SampleCppLinq.cpp new file mode 100644 index 0000000..e459e4b --- /dev/null +++ b/Ix++/samples/SampleCppLinq/SampleCppLinq.cpp @@ -0,0 +1,128 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +// SampleCppLinq.cpp : Defines the entry point for the console application. +// + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +vector load_data(); +string extract_value(const string& input, const string& key); + + +void run() +{ + using namespace cpplinq; + + struct item { + string args; + int concurrency; + double time; + + item(const string& input) { + args = extract_value(input, "args"); + concurrency = atoi( extract_value(input, "concurrency").c_str() ); + time = atof( extract_value(input, "time").c_str() ); + } + }; + + auto data_unparsed = load_data(); + auto data_parsed = + from(data_unparsed) + .select([](const string& line) { return item(line); }) + .to_vector(); + + cout << "data loaded" << endl; + + auto data = + from(data_parsed) + .groupby([](const item& i) { return i.args; }); + + for (auto giter = data.begin(), end = data.end(); giter != end; ++giter) + { + auto& g = *giter; + + cout << "arguments: " << g.key << endl; + + cout << "concurrency, mean, |, raw_data," << endl; + auto seq = + from(g) + .groupby([](const item& i) { return i.concurrency; }); + + for (auto giter = seq.begin(), end = seq.end(); giter != end; ++giter) + { + auto& g = *giter; + + cout << g.key << ", "; + + auto times = from(g).select([](const item& i) { return i.time; }); + + auto n = from(g).count(); + auto sum = std::accumulate(times.begin(), times.end(), 0.0); + + cout << (sum / n) << ", |"; + + for (auto timeIter = times.begin(), end = times.end(); + timeIter != end; + ++timeIter) + { + cout << ", " << *timeIter; + } + cout << endl; + } + } +} + + +int main() +{ + try { + run(); + } catch (exception& e) { + cerr << "exception: " << e.what() << endl; + } +} + +vector load_data() +{ + ifstream datafile("data.txt"); + vector v; + string line; + + if (datafile.fail()) + throw logic_error("could not find file"); + + while(getline(datafile, line)) + v.push_back(line); + + return v; +} + +regex key_value_pair("'([^\']*)'\\s*[:,]\\s*(\\d+(?:\\.\\d+)?|'[^']*')"); + +string extract_value(const string& input, const string& key) +{ + const std::sregex_iterator end; + for (std::sregex_iterator i(input.cbegin(), input.cend(), key_value_pair); + i != end; + ++i) + { + if ((*i)[1] == key) + { + return (*i)[2]; + } + } + throw std::range_error("search key not found"); +} diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.sln b/Ix++/samples/SampleCppLinq/SampleCppLinq.sln new file mode 100644 index 0000000..32769e0 --- /dev/null +++ b/Ix++/samples/SampleCppLinq/SampleCppLinq.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 11 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SampleCppLinq", "SampleCppLinq.vcxproj", "{B65551BA-E1BA-4735-BA51-FFA83D64823E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {B65551BA-E1BA-4735-BA51-FFA83D64823E}.Debug|Win32.ActiveCfg = Debug|Win32 + {B65551BA-E1BA-4735-BA51-FFA83D64823E}.Debug|Win32.Build.0 = Debug|Win32 + {B65551BA-E1BA-4735-BA51-FFA83D64823E}.Release|Win32.ActiveCfg = Release|Win32 + {B65551BA-E1BA-4735-BA51-FFA83D64823E}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj b/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj new file mode 100644 index 0000000..83dd175 --- /dev/null +++ b/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj @@ -0,0 +1,92 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + $(VCTargetsPath11) + + + {B65551BA-E1BA-4735-BA51-FFA83D64823E} + Win32Proj + SampleCppLinq + + + + Application + true + v110 + Unicode + + + Application + false + v110 + true + Unicode + + + + + + + + + + + + + true + d:\work\CppLinq Project\src;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + + + false + d:\work\CppLinq Project\src;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + + + Console + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + + + Console + true + true + true + + + + + + + + + + + + \ No newline at end of file diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters b/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters new file mode 100644 index 0000000..3e3685f --- /dev/null +++ b/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters @@ -0,0 +1,25 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + + \ No newline at end of file diff --git a/Ix++/samples/SampleCppLinq/data.txt b/Ix++/samples/SampleCppLinq/data.txt new file mode 100644 index 0000000..b16aea6 --- /dev/null +++ b/Ix++/samples/SampleCppLinq/data.txt @@ -0,0 +1,655 @@ +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22437888.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.9785421875}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26136576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.956228125}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22503424.0, 'privatemem': 25968640.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 71.741975}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26177536.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.189240625}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22323200.0, 'privatemem': 25808896.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.7897296875}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14917632.0, 'privatemem': 20385792.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.734965625}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15060992.0, 'privatemem': 20545536.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.028878125}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15052800.0, 'privatemem': 20529152.0, 'nonpaged': 26768.0, 'virtualmem': 577224704.0, 'time': 45.5304375}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14934016.0, 'privatemem': 20406272.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.898271875}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14991360.0, 'privatemem': 20447232.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.425371875}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 32.748084375}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26202112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.5510765625}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22556672.0, 'privatemem': 26021888.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.0404453125}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26038272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 34.0872890625}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25976832.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.026740625}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15093760.0, 'privatemem': 21082112.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 23.0056984375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20918272.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2537171875}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20905984.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2316484375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15192064.0, 'privatemem': 20910080.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.259509375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 20979712.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.3385359375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25952256.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2717265625}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2175609375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26042368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.07530625}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.281884375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26185728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.05386875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15245312.0, 'privatemem': 21233664.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.3586671875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15310848.0, 'privatemem': 21250048.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.70775625}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15347712.0, 'privatemem': 21254144.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.6456703125}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 21180416.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.303421875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15335424.0, 'privatemem': 21299200.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.4817796875}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 25980928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7404328125}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22482944.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2058328125}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22646784.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 17.3264390625}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.233396875}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.4778453125}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15200256.0, 'privatemem': 21196800.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 12.3187859375}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15474688.0, 'privatemem': 21725184.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 11.6904421875}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15384576.0, 'privatemem': 21630976.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.795390625}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15364096.0, 'privatemem': 21606400.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.5224484375}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15343616.0, 'privatemem': 21590016.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.4604203125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22536192.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.291790625}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22753280.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8192703125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25919488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1479078125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22728704.0, 'privatemem': 26058752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7772765625}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4325453125}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15458304.0, 'privatemem': 21950464.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 11.653565625}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15622144.0, 'privatemem': 22114304.0, 'nonpaged': 28688.0, 'virtualmem': 610779136.0, 'time': 11.60025}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15491072.0, 'privatemem': 21975040.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 15.956359375}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15429632.0, 'privatemem': 21938176.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 16.7639015625}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15560704.0, 'privatemem': 22102016.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 12.432678125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.482378125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22724608.0, 'privatemem': 26005504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.6995578125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22601728.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7111109375}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22675456.0, 'privatemem': 26017792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.24071875}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22822912.0, 'privatemem': 26206208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1442453125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15446016.0, 'privatemem': 22118400.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.3196953125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15351808.0, 'privatemem': 21860352.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 13.8507890625}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15536128.0, 'privatemem': 22384640.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.411578125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15728640.0, 'privatemem': 22585344.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.3764765625}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22331392.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.253040625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22650880.0, 'privatemem': 25956352.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1586765625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22700032.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2853515625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9393859375}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22597632.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.95501875}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22794240.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.9703578125}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15720448.0, 'privatemem': 22822912.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.88916875}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15872000.0, 'privatemem': 22978560.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.7966875}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15642624.0, 'privatemem': 22474752.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.072915625}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15605760.0, 'privatemem': 22548480.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.3262265625}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15503360.0, 'privatemem': 22335488.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.3073703125}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26075136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7767140625}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22683648.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.6023046875}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.590659375}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26128384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.797509375}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26001408.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.114903125}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15843328.0, 'privatemem': 23093248.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.8031640625}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22933504.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.78183125}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15626240.0, 'privatemem': 22466560.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.79186875}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15998976.0, 'privatemem': 23089152.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.6507984375}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15769600.0, 'privatemem': 22892544.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.7464046875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26107904.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5812421875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26030080.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.8055078125}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 23019520.0, 'privatemem': 26374144.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.661046875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22810624.0, 'privatemem': 26165248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8447890625}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26157056.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7037859375}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15937536.0, 'privatemem': 23482368.0, 'nonpaged': 30384.0, 'virtualmem': 640139264.0, 'time': 9.9560078125}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22953984.0, 'nonpaged': 29888.0, 'virtualmem': 631750656.0, 'time': 9.9779875}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15806464.0, 'privatemem': 23216128.0, 'nonpaged': 30144.0, 'virtualmem': 635944960.0, 'time': 10.0446703125}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15765504.0, 'privatemem': 23171072.0, 'nonpaged': 30128.0, 'virtualmem': 635944960.0, 'time': 9.8954875}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22679552.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.1007609375}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4936453125}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.54201875}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8461453125}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5201171875}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26173440.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.7564125}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16015360.0, 'privatemem': 23687168.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.308821875}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15978496.0, 'privatemem': 23896064.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3545609375}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16105472.0, 'privatemem': 23773184.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.39604375}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16003072.0, 'privatemem': 23670784.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 11.3077953125}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23347200.0, 'nonpaged': 30272.0, 'virtualmem': 640139264.0, 'time': 11.2470921875}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26017792.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.5840734375}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22843392.0, 'privatemem': 26238976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.7056515625}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22765568.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.4621296875}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.7261640625}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22659072.0, 'privatemem': 26132480.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.43949375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24227840.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 10.1509875}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23486464.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.4571375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15953920.0, 'privatemem': 23937024.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.21300625}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16056320.0, 'privatemem': 24068096.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3364984375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15851520.0, 'privatemem': 23621632.0, 'nonpaged': 30752.0, 'virtualmem': 648527872.0, 'time': 10.205690625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4346625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22941696.0, 'privatemem': 26288128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.588709375}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25997312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.383815625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22818816.0, 'privatemem': 26148864.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.60400625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22716416.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3768921875}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16101376.0, 'privatemem': 24428544.0, 'nonpaged': 31712.0, 'virtualmem': 665305088.0, 'time': 9.846940625}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16089088.0, 'privatemem': 24199168.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 11.1524609375}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16199680.0, 'privatemem': 24178688.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 9.9980328125}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16023552.0, 'privatemem': 23977984.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 11.2873078125}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24387584.0, 'nonpaged': 31472.0, 'virtualmem': 661110784.0, 'time': 9.934396875}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22781952.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4010015625}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25985024.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2167890625}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26152960.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.4800796875}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26050560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.449178125}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26058752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2931078125}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16310272.0, 'privatemem': 25399296.0, 'nonpaged': 32912.0, 'virtualmem': 686276608.0, 'time': 10.06823125}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16154624.0, 'privatemem': 24883200.0, 'nonpaged': 32432.0, 'virtualmem': 677888000.0, 'time': 10.0306984375}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16171008.0, 'privatemem': 25038848.0, 'nonpaged': 32672.0, 'virtualmem': 682082304.0, 'time': 10.06961875}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16216064.0, 'privatemem': 24817664.0, 'nonpaged': 32192.0, 'virtualmem': 673693696.0, 'time': 10.0746796875}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16375808.0, 'privatemem': 25542656.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 10.037271875}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25985024.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4086859375}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3663890625}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26034176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3019828125}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26144768.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.389559375}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22593536.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2155328125}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16252928.0, 'privatemem': 25710592.0, 'nonpaged': 33632.0, 'virtualmem': 698859520.0, 'time': 9.93735}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16265216.0, 'privatemem': 25427968.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.9944796875}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16236544.0, 'privatemem': 25595904.0, 'nonpaged': 33392.0, 'virtualmem': 694665216.0, 'time': 9.94461875}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16257024.0, 'privatemem': 25403392.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.94913125}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16424960.0, 'privatemem': 26009600.0, 'nonpaged': 33872.0, 'virtualmem': 703053824.0, 'time': 9.9931234375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26169344.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.376209375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22528000.0, 'privatemem': 25866240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2378046875}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26128384.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.225084375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 26038272.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.23915625}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26140672.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.35693125}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16650240.0, 'privatemem': 26861568.0, 'nonpaged': 34832.0, 'virtualmem': 719831040.0, 'time': 9.7327859375}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16547840.0, 'privatemem': 26378240.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.775103125}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16654336.0, 'privatemem': 26513408.0, 'nonpaged': 34472.0, 'virtualmem': 713539584.0, 'time': 9.8092875}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16445440.0, 'privatemem': 26304512.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.834784375}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16510976.0, 'privatemem': 26243072.0, 'nonpaged': 34112.0, 'virtualmem': 707248128.0, 'time': 9.9615171875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.234246875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26140672.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1942140625}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26079232.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3161734375}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22708224.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2072671875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2228828125}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16568320.0, 'privatemem': 27033600.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8727921875}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16764928.0, 'privatemem': 27238400.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8168890625}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16842752.0, 'privatemem': 27193344.0, 'nonpaged': 35192.0, 'virtualmem': 726122496.0, 'time': 9.8725515625}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16732160.0, 'privatemem': 27230208.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8796578125}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16576512.0, 'privatemem': 26882048.0, 'nonpaged': 35072.0, 'virtualmem': 724025344.0, 'time': 9.851103125}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22679552.0, 'privatemem': 25993216.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.183775}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1523140625}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2646}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26025984.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.190975}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26173440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.290859375}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17313792.0, 'privatemem': 29270016.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 9.8081125}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17297408.0, 'privatemem': 29560832.0, 'nonpaged': 38672.0, 'virtualmem': 786939904.0, 'time': 9.803896875}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17514496.0, 'privatemem': 29667328.0, 'nonpaged': 38552.0, 'virtualmem': 784842752.0, 'time': 10.44371875}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17350656.0, 'privatemem': 29356032.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 10.5586140625}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17219584.0, 'privatemem': 29265920.0, 'nonpaged': 38072.0, 'virtualmem': 776454144.0, 'time': 11.02230625}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29392896.0, 'privatemem': 32837632.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.5534375}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32817152.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.04296875}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29323264.0, 'privatemem': 32690176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5768078125}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29327360.0, 'privatemem': 32718848.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1712328125}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.193025}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17764352.0, 'privatemem': 30863360.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7636984375}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17707008.0, 'privatemem': 30818304.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7707}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17625088.0, 'privatemem': 30760960.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.812396875}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17649664.0, 'privatemem': 30711808.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 10.313584375}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17674240.0, 'privatemem': 30810112.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.8304125}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1279546875}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1256796875}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29585408.0, 'privatemem': 32956416.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.14424375}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29421568.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1787703125}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29347840.0, 'privatemem': 32718848.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121146875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17829888.0, 'privatemem': 32083968.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7840515625}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17981440.0, 'privatemem': 32190464.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.774884375}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17907712.0, 'privatemem': 32178176.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7712421875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17809408.0, 'privatemem': 32092160.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.883371875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 18104320.0, 'privatemem': 32366592.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.8319875}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29380608.0, 'privatemem': 32731136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.139365625}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29401088.0, 'privatemem': 32792576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1221734375}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29298688.0, 'privatemem': 32735232.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3343921875}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29564928.0, 'privatemem': 32948224.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.144190625}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32894976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.147003125}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18358272.0, 'privatemem': 34308096.0, 'nonpaged': 45032.0, 'virtualmem': 898088960.0, 'time': 9.80116875}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18325504.0, 'privatemem': 33714176.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.898659375}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18300928.0, 'privatemem': 33689600.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7784}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18210816.0, 'privatemem': 33574912.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.9189640625}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18202624.0, 'privatemem': 33566720.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7934265625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29495296.0, 'privatemem': 32886784.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.111571875}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29429760.0, 'privatemem': 32776192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.199890625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29442048.0, 'privatemem': 32886784.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.11831875}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29597696.0, 'privatemem': 32931840.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1347890625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32739328.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.171440625}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19292160.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7851578125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19222528.0, 'privatemem': 37990400.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.759603125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19308544.0, 'privatemem': 38092800.0, 'nonpaged': 49928.0, 'virtualmem': 981975040.0, 'time': 9.73698125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19214336.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7582359375}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19324928.0, 'privatemem': 38129664.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7412640625}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29474816.0, 'privatemem': 32837632.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.169203125}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29614080.0, 'privatemem': 32976896.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1191375}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29626368.0, 'privatemem': 32968704.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1113484375}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 33058816.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.1464140625}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32747520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1111234375}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 20041728.0, 'privatemem': 41103360.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.7898}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19968000.0, 'privatemem': 41009152.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.855309375}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19824640.0, 'privatemem': 40890368.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9260921875}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19947520.0, 'privatemem': 41054208.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9416703125}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19808256.0, 'privatemem': 40882176.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.8916515625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29691904.0, 'privatemem': 33034240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.11079375}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32755712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1449734375}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29315072.0, 'privatemem': 32628736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13280625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1016015625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32735232.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1100125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20836352.0, 'privatemem': 44212224.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.02668125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20934656.0, 'privatemem': 44322816.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.9877078125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 21037056.0, 'privatemem': 45981696.0, 'nonpaged': 60152.0, 'virtualmem': 1162330112.0, 'time': 9.9358015625}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20824064.0, 'privatemem': 44150784.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.98304375}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20856832.0, 'privatemem': 44257280.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.009546875}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 33009664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.0923984375}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.163709375}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32849920.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1063703125}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29450240.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0826171875}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29528064.0, 'privatemem': 32833536.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.086065625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21835776.0, 'privatemem': 48500736.0, 'nonpaged': 63032.0, 'virtualmem': 1212661760.0, 'time': 10.0842015625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21663744.0, 'privatemem': 47255552.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.0181609375}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21577728.0, 'privatemem': 47198208.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.846165625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21389312.0, 'privatemem': 46759936.0, 'nonpaged': 61112.0, 'virtualmem': 1179107328.0, 'time': 11.5423390625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21254144.0, 'privatemem': 46899200.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 11.306240625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.85168125}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 33005568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.58709375}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32862208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5917140625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32821248.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1530390625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29405184.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08974375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23420928.0, 'privatemem': 55808000.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2232734375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23494656.0, 'privatemem': 55554048.0, 'nonpaged': 72392.0, 'virtualmem': 1376239616.0, 'time': 10.3183484375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23584768.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.3544203125}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23617536.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2523703125}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23609344.0, 'privatemem': 55885824.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.154103125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29544448.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0866078125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29507584.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0993953125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32841728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.10189375}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.0977}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29581312.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0975171875}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24719360.0, 'privatemem': 61693952.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.415759375}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24862720.0, 'privatemem': 61919232.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2971765625}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24784896.0, 'privatemem': 61628416.0, 'nonpaged': 80552.0, 'virtualmem': 1518845952.0, 'time': 10.34406875}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24969216.0, 'privatemem': 61984768.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2925640625}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24752128.0, 'privatemem': 61415424.0, 'nonpaged': 80312.0, 'virtualmem': 1514651648.0, 'time': 10.284221875}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29650944.0, 'privatemem': 33046528.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.15705625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29700096.0, 'privatemem': 33017856.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.122590625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29659136.0, 'privatemem': 33026048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08970625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32915456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1275171875}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32882688.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.14285}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26378240.0, 'privatemem': 67780608.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.4648703125}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26124288.0, 'privatemem': 67293184.0, 'nonpaged': 88112.0, 'virtualmem': 1653063680.0, 'time': 10.5292671875}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26046464.0, 'privatemem': 67276800.0, 'nonpaged': 87992.0, 'virtualmem': 1648869376.0, 'time': 10.491190625}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26034176.0, 'privatemem': 67489792.0, 'nonpaged': 88232.0, 'virtualmem': 1653063680.0, 'time': 10.5243890625}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26234880.0, 'privatemem': 67649536.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.5925109375}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32944128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.150478125}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29741056.0, 'privatemem': 33099776.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1190796875}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 33005568.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.178025}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32948224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1318578125}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29933568.0, 'privatemem': 33325056.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 13.130896875}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27303936.0, 'privatemem': 73404416.0, 'nonpaged': 96272.0, 'virtualmem': 1795670016.0, 'time': 10.5394765625}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27607040.0, 'privatemem': 73625600.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.565934375}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27287552.0, 'privatemem': 72835072.0, 'nonpaged': 95552.0, 'virtualmem': 1783087104.0, 'time': 10.6236890625}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27480064.0, 'privatemem': 73379840.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.57548125}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27201536.0, 'privatemem': 73240576.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.68160625}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29671424.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.175703125}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29827072.0, 'privatemem': 33165312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1375234375}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29777920.0, 'privatemem': 33116160.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121140625}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 32870400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1075078125}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29704192.0, 'privatemem': 33001472.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.150696875}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29577216.0, 'privatemem': 84500480.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.8671703125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29835264.0, 'privatemem': 84918272.0, 'nonpaged': 111392.0, 'virtualmem': 2059911168.0, 'time': 10.893078125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29667328.0, 'privatemem': 84197376.0, 'nonpaged': 110672.0, 'virtualmem': 2047328256.0, 'time': 10.899709375}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29663232.0, 'privatemem': 84520960.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.9027828125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 84615168.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.904421875}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 32960512.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.132984375}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29839360.0, 'privatemem': 33132544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13160625}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29978624.0, 'privatemem': 33378304.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.1281796875}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33095680.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1194140625}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29880320.0, 'privatemem': 33148928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.140121875}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32329728.0, 'privatemem': 96473088.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.03265625}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32165888.0, 'privatemem': 96047104.0, 'nonpaged': 126272.0, 'virtualmem': 2319958016.0, 'time': 11.1066328125}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32178176.0, 'privatemem': 96284672.0, 'nonpaged': 126512.0, 'virtualmem': 2324152320.0, 'time': 11.0177765625}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32161792.0, 'privatemem': 96284672.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.15135}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32096256.0, 'privatemem': 96309248.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.1041015625}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33148928.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.127125}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29913088.0, 'privatemem': 33284096.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1395265625}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29921280.0, 'privatemem': 33263616.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.136646875}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29761536.0, 'privatemem': 33140736.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1379828125}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29818880.0, 'privatemem': 33173504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.7975015625}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34549760.0, 'privatemem': 107462656.0, 'nonpaged': 141632.0, 'virtualmem': 2588393472.0, 'time': 12.9889609375}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34643968.0, 'privatemem': 108085248.0, 'nonpaged': 142352.0, 'virtualmem': 2600976384.0, 'time': 13.0880796875}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34697216.0, 'privatemem': 107810816.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 13.2690765625}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34508800.0, 'privatemem': 107683840.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 12.4901671875}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34443264.0, 'privatemem': 107638784.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 11.23786875}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29847552.0, 'privatemem': 33222656.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.127740625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29859840.0, 'privatemem': 33206272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22630625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29896704.0, 'privatemem': 33259520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1849640625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29884416.0, 'privatemem': 33206272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.13985}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33333248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1424328125}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37142528.0, 'privatemem': 119185408.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.397996875}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37056512.0, 'privatemem': 119328768.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.38355}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37068800.0, 'privatemem': 119164928.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.4034015625}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37187584.0, 'privatemem': 119382016.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.341525}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37076992.0, 'privatemem': 119296000.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.373334375}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30105600.0, 'privatemem': 33378304.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.18291875}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30064640.0, 'privatemem': 33406976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.201753125}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30154752.0, 'privatemem': 33447936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1939015625}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30044160.0, 'privatemem': 33349632.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2285859375}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30068736.0, 'privatemem': 33341440.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1834984375}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47366144.0, 'privatemem': 141705216.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.7742625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47321088.0, 'privatemem': 141434880.0, 'nonpaged': 187712.0, 'virtualmem': 3393699840.0, 'time': 11.8519890625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47198208.0, 'privatemem': 141729792.0, 'nonpaged': 188432.0, 'virtualmem': 3406282752.0, 'time': 11.8748625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47349760.0, 'privatemem': 141578240.0, 'nonpaged': 187952.0, 'virtualmem': 3397894144.0, 'time': 11.80855625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47333376.0, 'privatemem': 141635584.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.8793171875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30441472.0, 'privatemem': 33677312.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1907140625}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30380032.0, 'privatemem': 33607680.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.224996875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30326784.0, 'privatemem': 33628160.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1955234375}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30355456.0, 'privatemem': 33726464.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 13.1947671875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30322688.0, 'privatemem': 33738752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2064796875}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52543488.0, 'privatemem': 163958784.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 11.974178125}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52502528.0, 'privatemem': 164315136.0, 'nonpaged': 219512.0, 'virtualmem': 3955736576.0, 'time': 11.9167046875}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52707328.0, 'privatemem': 164122624.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.118128125}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52293632.0, 'privatemem': 163651584.0, 'nonpaged': 218792.0, 'virtualmem': 3943153664.0, 'time': 12.049109375}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52748288.0, 'privatemem': 163999744.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.0723515625}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30642176.0, 'privatemem': 33882112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1681703125}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30302208.0, 'privatemem': 33697792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1825015625}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30408704.0, 'privatemem': 33726464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2253203125}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30486528.0, 'privatemem': 33800192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.250696875}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30560256.0, 'privatemem': 33894400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.174471875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58105856.0, 'privatemem': 186347520.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.09041875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57851904.0, 'privatemem': 186142720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9983140625}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57663488.0, 'privatemem': 185761792.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.26386875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57929728.0, 'privatemem': 186257408.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9970984375}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58085376.0, 'privatemem': 186654720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 12.0862875}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30867456.0, 'privatemem': 34107392.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2160328125}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30945280.0, 'privatemem': 34258944.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.2101375}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31059968.0, 'privatemem': 34291712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3171546875}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31064064.0, 'privatemem': 34279424.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2282890625}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31006720.0, 'privatemem': 34263040.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.209078125}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63021056.0, 'privatemem': 208171008.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 13.048375}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63369216.0, 'privatemem': 208424960.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.2770109375}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63447040.0, 'privatemem': 208539648.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.228196875}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63488000.0, 'privatemem': 208715776.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.670853125}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63070208.0, 'privatemem': 208207872.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.4422}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31617024.0, 'privatemem': 34848768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2811921875}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31719424.0, 'privatemem': 34897920.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22355625}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31494144.0, 'privatemem': 34746368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22349375}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31694848.0, 'privatemem': 34947072.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2325609375}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31547392.0, 'privatemem': 34807808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.767953125}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 73158656.0, 'privatemem': 252420096.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 15.0598109375}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 65974272.0, 'privatemem': 252903424.0, 'nonpaged': 342152.0, 'virtualmem': 6099025920.0, 'time': 13.8913953125}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66895872.0, 'privatemem': 253501440.0, 'nonpaged': 342632.0, 'virtualmem': 6107414528.0, 'time': 13.2943546875}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 67772416.0, 'privatemem': 252964864.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.7788609375}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66498560.0, 'privatemem': 252874752.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.8031625}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24178688.0, 'privatemem': 27402240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.357275}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23916544.0, 'privatemem': 27070464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3384296875}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24154112.0, 'privatemem': 27303936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3860484375}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24080384.0, 'privatemem': 27303936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.40868125}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23764992.0, 'privatemem': 26914816.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3454890625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74870784.0, 'privatemem': 296960000.0, 'nonpaged': 403512.0, 'virtualmem': 7172767744.0, 'time': 13.6358265625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 84811776.0, 'privatemem': 298262528.0, 'nonpaged': 403832.0, 'virtualmem': 7176962048.0, 'time': 14.18599375}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75407360.0, 'privatemem': 296779776.0, 'nonpaged': 403592.0, 'virtualmem': 7172767744.0, 'time': 13.6721390625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75026432.0, 'privatemem': 296505344.0, 'nonpaged': 403112.0, 'virtualmem': 7164379136.0, 'time': 13.3102890625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74461184.0, 'privatemem': 296538112.0, 'nonpaged': 403272.0, 'virtualmem': 7168573440.0, 'time': 14.0042234375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24694784.0, 'privatemem': 27824128.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3436484375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24739840.0, 'privatemem': 27815936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3563359375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24772608.0, 'privatemem': 27918336.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4315375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24756224.0, 'privatemem': 27865088.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.345803125}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24608768.0, 'privatemem': 27750400.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.402634375}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95748096.0, 'privatemem': 343252992.0, 'nonpaged': 465312.0, 'virtualmem': 8267284480.0, 'time': 14.8233890625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 96260096.0, 'privatemem': 343367680.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.9048890625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95764480.0, 'privatemem': 342867968.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.65851875}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95637504.0, 'privatemem': 342515712.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.7174265625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95924224.0, 'privatemem': 342884352.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.8882921875}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25047040.0, 'privatemem': 28094464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3807953125}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24981504.0, 'privatemem': 28151808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.398909375}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25075712.0, 'privatemem': 28147712.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.359221875}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25006080.0, 'privatemem': 28098560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3784}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24997888.0, 'privatemem': 28069888.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3560390625}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 105529344.0, 'privatemem': 386404352.0, 'nonpaged': 526512.0, 'virtualmem': 9336832000.0, 'time': 15.17243125}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106209280.0, 'privatemem': 387317760.0, 'nonpaged': 526992.0, 'virtualmem': 9345220608.0, 'time': 15.41375625}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 107094016.0, 'privatemem': 388059136.0, 'nonpaged': 526752.0, 'virtualmem': 9341026304.0, 'time': 15.4270546875}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106483712.0, 'privatemem': 387428352.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.0365046875}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106057728.0, 'privatemem': 386617344.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.11465}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28733440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4772109375}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29986816.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.39680625}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33005568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.43141875}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28782592.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4375484375}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29941760.0, 'privatemem': 33050624.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 13.40918125}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 124895232.0, 'privatemem': 473268224.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.8352921875}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125243392.0, 'privatemem': 474202112.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.9860609375}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 126054400.0, 'privatemem': 474787840.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.8798015625}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125100032.0, 'privatemem': 473649152.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.90209375}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 127406080.0, 'privatemem': 482037760.0, 'nonpaged': 658512.0, 'virtualmem': 11643699200.0, 'time': 16.0772640625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30760960.0, 'privatemem': 33771520.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.4638640625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30720000.0, 'privatemem': 33730560.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4992015625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30593024.0, 'privatemem': 33632256.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.460190625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30691328.0, 'privatemem': 33710080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.584534375}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30756864.0, 'privatemem': 33738752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.8325828125}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145821696.0, 'privatemem': 562421760.0, 'nonpaged': 772032.0, 'virtualmem': 13627604992.0, 'time': 18.0121359375}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145391616.0, 'privatemem': 562782208.0, 'nonpaged': 772416.0, 'virtualmem': 13635993600.0, 'time': 16.273371875}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145211392.0, 'privatemem': 561577984.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.684478125}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145367040.0, 'privatemem': 561598464.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.70395}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145969152.0, 'privatemem': 562495488.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.7380234375}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31399936.0, 'privatemem': 34484224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5152703125}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31645696.0, 'privatemem': 34541568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5179421875}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31395840.0, 'privatemem': 34435072.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.486846875}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34500608.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5053265625}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31473664.0, 'privatemem': 34447360.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.506196875}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166944768.0, 'privatemem': 650125312.0, 'nonpaged': 895176.0, 'virtualmem': 15795929088.0, 'time': 17.12616875}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166453248.0, 'privatemem': 650084352.0, 'nonpaged': 895656.0, 'virtualmem': 15804317696.0, 'time': 17.1012453125}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166957056.0, 'privatemem': 650522624.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.041084375}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166461440.0, 'privatemem': 651186176.0, 'nonpaged': 896136.0, 'virtualmem': 15812706304.0, 'time': 17.265559375}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166281216.0, 'privatemem': 650743808.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.20788125}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33193984.0, 'privatemem': 36044800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.543359375}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33120256.0, 'privatemem': 35979264.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5913015625}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35794944.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5597421875}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35885056.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.561975}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33013760.0, 'privatemem': 35872768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.552240625}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188612608.0, 'privatemem': 740990976.0, 'nonpaged': 1019232.0, 'virtualmem': 17964384256.0, 'time': 18.23205}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190369792.0, 'privatemem': 742092800.0, 'nonpaged': 1018176.0, 'virtualmem': 17947607040.0, 'time': 18.1267921875}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190291968.0, 'privatemem': 751833088.0, 'nonpaged': 1034976.0, 'virtualmem': 18241208320.0, 'time': 18.278765625}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 187871232.0, 'privatemem': 739778560.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 18.356121875}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188469248.0, 'privatemem': 739135488.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 17.9174328125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34922496.0, 'privatemem': 37539840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.705434375}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37617664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.677278125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37523456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.64224375}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35012608.0, 'privatemem': 37642240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.65468125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35115008.0, 'privatemem': 37711872.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.70276875}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228339712.0, 'privatemem': 915566592.0, 'nonpaged': 1264176.0, 'virtualmem': 22246768640.0, 'time': 19.006409375}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 229093376.0, 'privatemem': 916045824.0, 'nonpaged': 1264296.0, 'virtualmem': 22263349248.0, 'time': 19.33424375}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228802560.0, 'privatemem': 915972096.0, 'nonpaged': 1264184.0, 'virtualmem': 22263349248.0, 'time': 19.201040625}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228282368.0, 'privatemem': 915853312.0, 'nonpaged': 1263936.0, 'virtualmem': 22242574336.0, 'time': 19.1797125}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 227971072.0, 'privatemem': 915865600.0, 'nonpaged': 1264896.0, 'virtualmem': 22259351552.0, 'time': 20.5840234375}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36610048.0, 'privatemem': 39178240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2996234375}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36446208.0, 'privatemem': 39006208.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2134390625}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36413440.0, 'privatemem': 39055360.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.35226875}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36429824.0, 'privatemem': 39075840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8014796875}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36474880.0, 'privatemem': 39116800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7755546875}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 267964416.0, 'privatemem': 1090080768.0, 'nonpaged': 1509464.0, 'virtualmem': 26549927936.0, 'time': 19.5823140625}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 268500992.0, 'privatemem': 1091354624.0, 'nonpaged': 1509816.0, 'virtualmem': 26554122240.0, 'time': 19.5744}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269398016.0, 'privatemem': 1090744320.0, 'nonpaged': 1509576.0, 'virtualmem': 26549927936.0, 'time': 19.7508015625}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269123584.0, 'privatemem': 1093181440.0, 'nonpaged': 1514664.0, 'virtualmem': 26642202624.0, 'time': 19.75071875}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269733888.0, 'privatemem': 1091674112.0, 'nonpaged': 1511384.0, 'virtualmem': 26583482368.0, 'time': 19.5216640625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36532224.0, 'privatemem': 39153664.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.9015625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36720640.0, 'privatemem': 39264256.0, 'nonpaged': 25864.0, 'virtualmem': 564969472.0, 'time': 13.90245}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31596544.0, 'privatemem': 34111488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8932265625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34131968.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.9260484375}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34066432.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.954315625}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 315875328.0, 'privatemem': 1271836672.0, 'nonpaged': 1755264.0, 'virtualmem': 30861475840.0, 'time': 19.696196875}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 312127488.0, 'privatemem': 1268944896.0, 'nonpaged': 1755944.0, 'virtualmem': 30869929984.0, 'time': 19.7884125}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313524224.0, 'privatemem': 1270001664.0, 'nonpaged': 1755344.0, 'virtualmem': 30861475840.0, 'time': 19.5355734375}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313815040.0, 'privatemem': 1271222272.0, 'nonpaged': 1756064.0, 'virtualmem': 30874058752.0, 'time': 19.61661875}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 314990592.0, 'privatemem': 1271472128.0, 'nonpaged': 1755624.0, 'virtualmem': 30865735680.0, 'time': 20.050821875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38105088.0, 'privatemem': 40636416.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.0955625}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37982208.0, 'privatemem': 40583168.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.040196875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38129664.0, 'privatemem': 40685568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.042221875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38043648.0, 'privatemem': 40665088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 14.1191921875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37933056.0, 'privatemem': 40538112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.0314734375}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 356925440.0, 'privatemem': 1448673280.0, 'nonpaged': 2001264.0, 'virtualmem': 35157557248.0, 'time': 20.15775}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 354324480.0, 'privatemem': 1447530496.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.9642671875}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355999744.0, 'privatemem': 1446727680.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.937840625}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355708928.0, 'privatemem': 1447718912.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 21.3836453125}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355086336.0, 'privatemem': 1448427520.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 20.5806625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40574976.0, 'privatemem': 42999808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.212690625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40849408.0, 'privatemem': 43442176.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.26136875}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40611840.0, 'privatemem': 43065344.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2927234375}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 35049472.0, 'privatemem': 37515264.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 14.2932515625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40902656.0, 'privatemem': 43450368.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.29265625}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437157888.0, 'privatemem': 1799569408.0, 'nonpaged': 2493704.0, 'virtualmem': 43789238272.0, 'time': 22.39598125}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 438943744.0, 'privatemem': 1800122368.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3933875}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 454443008.0, 'privatemem': 1816186880.0, 'nonpaged': 2493264.0, 'virtualmem': 43797430272.0, 'time': 22.156965625}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 441925632.0, 'privatemem': 1810481152.0, 'nonpaged': 2503344.0, 'virtualmem': 43973591040.0, 'time': 22.4793375}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437071872.0, 'privatemem': 1798299648.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3045375}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43515904.0, 'privatemem': 45961216.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.59280625}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46112768.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.596046875}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43720704.0, 'privatemem': 46157824.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.590865625}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46100480.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.609971875}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43429888.0, 'privatemem': 45940736.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.6273390625}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 516640768.0, 'privatemem': 2149273600.0, 'nonpaged': 2984784.0, 'virtualmem': 52399816704.0, 'time': 26.321934375}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 517148672.0, 'privatemem': 2152136704.0, 'nonpaged': 2986944.0, 'virtualmem': 52437565440.0, 'time': 26.177103125}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 523063296.0, 'privatemem': 2156064768.0, 'nonpaged': 2985504.0, 'virtualmem': 52412399616.0, 'time': 26.05946875}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 518561792.0, 'privatemem': 2162417664.0, 'nonpaged': 2994864.0, 'virtualmem': 52575977472.0, 'time': 28.18605}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 525058048.0, 'privatemem': 2157924352.0, 'nonpaged': 2985264.0, 'virtualmem': 52408205312.0, 'time': 26.42195625}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40148992.0, 'privatemem': 42582016.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.0295875}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40206336.0, 'privatemem': 42512384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.990478125}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 45486080.0, 'privatemem': 47845376.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9103515625}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 44941312.0, 'privatemem': 47333376.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.9739078125}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 46559232.0, 'privatemem': 49074176.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.99918125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 601858048.0, 'privatemem': 2509008896.0, 'nonpaged': 3485304.0, 'virtualmem': 61158797312.0, 'time': 28.8111328125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 604540928.0, 'privatemem': 2506592256.0, 'nonpaged': 3477504.0, 'virtualmem': 61023174656.0, 'time': 28.554359375}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 607997952.0, 'privatemem': 2508111872.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.05818125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 606982144.0, 'privatemem': 2510180352.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.6098046875}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 603512832.0, 'privatemem': 2506928128.0, 'nonpaged': 3478584.0, 'virtualmem': 61041356800.0, 'time': 30.173225}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42070016.0, 'privatemem': 44314624.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2156484375}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42672128.0, 'privatemem': 44982272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 16.160125}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42905600.0, 'privatemem': 45236224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2525890625}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 43896832.0, 'privatemem': 46153728.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.3214}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42004480.0, 'privatemem': 44298240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.23181875}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 689721344.0, 'privatemem': 2865324032.0, 'nonpaged': 3968784.0, 'virtualmem': 69622706176.0, 'time': 31.0380265625}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 701034496.0, 'privatemem': 2882179072.0, 'nonpaged': 3982704.0, 'virtualmem': 69865975808.0, 'time': 31.334315625}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 685584384.0, 'privatemem': 2856980480.0, 'nonpaged': 3968664.0, 'virtualmem': 69621301248.0, 'time': 33.5692328125}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 697085952.0, 'privatemem': 2868523008.0, 'nonpaged': 3968784.0, 'virtualmem': 69637881856.0, 'time': 30.9457953125}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 690245632.0, 'privatemem': 2862125056.0, 'nonpaged': 3970344.0, 'virtualmem': 69650661376.0, 'time': 33.4727609375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55869440.0, 'privatemem': 58114048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.7086890625}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 56160256.0, 'privatemem': 58540032.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 15.7096078125}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 49836032.0, 'privatemem': 52043776.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2957859375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55492608.0, 'privatemem': 57851904.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.5145359375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 47857664.0, 'privatemem': 50147328.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.8469078125}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 862195712.0, 'privatemem': 3575685120.0, 'nonpaged': 4952784.0, 'virtualmem': 86889738240.0, 'time': 40.3810609375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 865746944.0, 'privatemem': 3578298368.0, 'nonpaged': 4952304.0, 'virtualmem': 86881349632.0, 'time': 36.3784328125}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 869675008.0, 'privatemem': 3581808640.0, 'nonpaged': 4952544.0, 'virtualmem': 86885543936.0, 'time': 38.871209375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 860774400.0, 'privatemem': 3582889984.0, 'nonpaged': 4966464.0, 'virtualmem': 87128813568.0, 'time': 43.21194375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 855191552.0, 'privatemem': 3567927296.0, 'nonpaged': 4952904.0, 'virtualmem': 86877351936.0, 'time': 38.48225625}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57565184.0, 'privatemem': 59461632.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.1426484375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 54370304.0, 'privatemem': 56492032.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.101009375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 62488576.0, 'privatemem': 64598016.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.84624375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57757696.0, 'privatemem': 59613184.0, 'nonpaged': 25640.0, 'virtualmem': 569163776.0, 'time': 15.9433421875}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 67629056.0, 'privatemem': 69304320.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.0379890625}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028907008.0, 'privatemem': 4283650048.0, 'nonpaged': 5936184.0, 'virtualmem': 104104235008.0, 'time': 53.8624046875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037115392.0, 'privatemem': 4290715648.0, 'nonpaged': 5936304.0, 'virtualmem': 104120815616.0, 'time': 53.877346875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037705216.0, 'privatemem': 4291125248.0, 'nonpaged': 5935824.0, 'virtualmem': 104112427008.0, 'time': 54.8691671875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1043337216.0, 'privatemem': 4301135872.0, 'nonpaged': 5935824.0, 'virtualmem': 104111026176.0, 'time': 46.317490625}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028558848.0, 'privatemem': 4282368000.0, 'nonpaged': 5936424.0, 'virtualmem': 104108429312.0, 'time': 53.502359375}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73793536.0, 'privatemem': 75640832.0, 'nonpaged': 26600.0, 'virtualmem': 577552384.0, 'time': 16.6419671875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74006528.0, 'privatemem': 75755520.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 16.59216875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74121216.0, 'privatemem': 75894784.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.6399796875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 75317248.0, 'privatemem': 77017088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.6508421875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73236480.0, 'privatemem': 75030528.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.776903125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1193185280.0, 'privatemem': 4992319488.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 59.2310265625}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186713600.0, 'privatemem': 4982370304.0, 'nonpaged': 6919584.0, 'virtualmem': 121317330944.0, 'time': 62.308228125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1204101120.0, 'privatemem': 5004546048.0, 'nonpaged': 6919704.0, 'virtualmem': 121333911552.0, 'time': 59.4607328125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186025472.0, 'privatemem': 4979195904.0, 'nonpaged': 6919824.0, 'virtualmem': 121321525248.0, 'time': 68.2966625}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1190494208.0, 'privatemem': 4990369792.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 65.9037140625}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 69914624.0, 'privatemem': 71544832.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.5821546875}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 82804736.0, 'privatemem': 84516864.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4147265625}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 80211968.0, 'privatemem': 81952768.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 17.2119453125}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 72941568.0, 'privatemem': 74739712.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.0826671875}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 57122816.0, 'privatemem': 59056128.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 15.8496921875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1363570688.0, 'privatemem': 5696401408.0, 'nonpaged': 7902864.0, 'virtualmem': 138542813184.0, 'time': 77.319371875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1359228928.0, 'privatemem': 5693067264.0, 'nonpaged': 7902504.0, 'virtualmem': 138522038272.0, 'time': 75.611196875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1382010880.0, 'privatemem': 5722746880.0, 'nonpaged': 7903224.0, 'virtualmem': 138563588096.0, 'time': 75.43135625}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1366474752.0, 'privatemem': 5719846912.0, 'nonpaged': 7935264.0, 'virtualmem': 139092529152.0, 'time': 77.2984921875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1380454400.0, 'privatemem': 5713457152.0, 'nonpaged': 7902744.0, 'virtualmem': 138555199488.0, 'time': 72.9519984375}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 82169856.0, 'privatemem': 84209664.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 18.2689421875}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 86765568.0, 'privatemem': 88666112.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 17.703690625}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89808896.0, 'privatemem': 91951104.0, 'nonpaged': 25744.0, 'virtualmem': 562872320.0, 'time': 17.698275}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 83464192.0, 'privatemem': 84893696.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.8156953125}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89182208.0, 'privatemem': 91365376.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 17.637353125}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1688113152.0, 'privatemem': 7102902272.0, 'nonpaged': 9870744.0, 'virtualmem': 172987879424.0, 'time': 109.5945375}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681657856.0, 'privatemem': 7097241600.0, 'nonpaged': 9870264.0, 'virtualmem': 172979490816.0, 'time': 112.0583734375}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1701982208.0, 'privatemem': 7125585920.0, 'nonpaged': 9876984.0, 'virtualmem': 173109383168.0, 'time': 108.868828125}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1696256000.0, 'privatemem': 7110664192.0, 'nonpaged': 9870384.0, 'virtualmem': 172979556352.0, 'time': 100.987990625}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681092608.0, 'privatemem': 7102992384.0, 'nonpaged': 9881424.0, 'virtualmem': 173160042496.0, 'time': 103.1147171875}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 88752128.0, 'privatemem': 90644480.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.194690625}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 91697152.0, 'privatemem': 93396992.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 19.1130046875}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 70430720.0, 'privatemem': 72364032.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 17.7690265625}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 85979136.0, 'privatemem': 87822336.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 19.166028125}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 87728128.0, 'privatemem': 89387008.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.178809375}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2026475520.0, 'privatemem': 8518123520.0, 'nonpaged': 11837784.0, 'virtualmem': 207459684352.0, 'time': 140.7092328125}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2036518912.0, 'privatemem': 8542306304.0, 'nonpaged': 11840544.0, 'virtualmem': 207512752128.0, 'time': 147.6286140625}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2027098112.0, 'privatemem': 8528797696.0, 'nonpaged': 11837424.0, 'virtualmem': 207455424512.0, 'time': 157.0997796875}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2029830144.0, 'privatemem': 8523378688.0, 'nonpaged': 11838144.0, 'virtualmem': 207470809088.0, 'time': 149.35805}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2018607104.0, 'privatemem': 8512258048.0, 'nonpaged': 11837544.0, 'virtualmem': 207443038208.0, 'time': 156.43776875}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 110104576.0, 'privatemem': 112001024.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 19.1979890625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 117399552.0, 'privatemem': 118956032.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.72220625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 102563840.0, 'privatemem': 104300544.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.6945328125}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 105697280.0, 'privatemem': 107380736.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.43420625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 106532864.0, 'privatemem': 108306432.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.3152046875}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2363232256.0, 'privatemem': 9939460096.0, 'nonpaged': 13804464.0, 'virtualmem': 241888612352.0, 'time': 184.053434375}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2365878272.0, 'privatemem': 9953259520.0, 'nonpaged': 13804344.0, 'virtualmem': 241900998656.0, 'time': 192.2616015625}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2358566912.0, 'privatemem': 9937661952.0, 'nonpaged': 13806264.0, 'virtualmem': 241918038016.0, 'time': 189.8282234375}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2342895616.0, 'privatemem': 9925849088.0, 'nonpaged': 13804224.0, 'virtualmem': 241884418048.0, 'time': 182.3936078125}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2347986944.0, 'privatemem': 9933496320.0, 'nonpaged': 13804824.0, 'virtualmem': 241892872192.0, 'time': 186.212921875}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 130637824.0, 'privatemem': 132468736.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 20.00561875}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 115064832.0, 'privatemem': 116396032.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 20.3946609375}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 72556544.0, 'privatemem': 74584064.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 17.1177015625}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 112943104.0, 'privatemem': 114147328.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 20.2790203125}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 129822720.0, 'privatemem': 131096576.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 20.95596875}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2690383872.0, 'privatemem': 11338743808.0, 'nonpaged': 15772944.0, 'virtualmem': 276378443776.0, 'time': 247.372325}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2684055552.0, 'privatemem': 11335376896.0, 'nonpaged': 15771504.0, 'virtualmem': 276344889344.0, 'time': 240.684809375}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2701897728.0, 'privatemem': 11360075776.0, 'nonpaged': 15772344.0, 'virtualmem': 276374052864.0, 'time': 235.606675}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2961162240.0, 'privatemem': 11630002176.0, 'nonpaged': 15773904.0, 'virtualmem': 276618567680.0, 'time': 277.3269875}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2682052608.0, 'privatemem': 11340992512.0, 'nonpaged': 15776304.0, 'virtualmem': 276428775424.0, 'time': 244.7224234375}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 138235904.0, 'privatemem': 139558912.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 21.6494125}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 89427968.0, 'privatemem': 90931200.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4579984375}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 130588672.0, 'privatemem': 131649536.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 21.278078125}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 135176192.0, 'privatemem': 136491008.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 21.5131796875}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 127688704.0, 'privatemem': 129499136.0, 'nonpaged': 26728.0, 'virtualmem': 581746688.0, 'time': 19.93003125}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3732779008.0, 'privatemem': 14553665536.0, 'nonpaged': 19709064.0, 'virtualmem': 345628565504.0, 'time': 353.601725}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3335438336.0, 'privatemem': 14157639680.0, 'nonpaged': 19704744.0, 'virtualmem': 345205465088.0, 'time': 356.084828125}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3416276992.0, 'privatemem': 14252584960.0, 'nonpaged': 19705824.0, 'virtualmem': 345296756736.0, 'time': 364.665215625}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3340185600.0, 'privatemem': 14166282240.0, 'nonpaged': 19705344.0, 'virtualmem': 345218048000.0, 'time': 330.89671875}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3341864960.0, 'privatemem': 14169149440.0, 'nonpaged': 19707504.0, 'virtualmem': 345255796736.0, 'time': 352.603725}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 119099392.0, 'privatemem': 120713216.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 21.3428921875}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139829248.0, 'privatemem': 141701120.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 23.1737}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 151707648.0, 'privatemem': 153325568.0, 'nonpaged': 26488.0, 'virtualmem': 577552384.0, 'time': 22.1648703125}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139603968.0, 'privatemem': 141705216.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 24.3582796875}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 126025728.0, 'privatemem': 128827392.0, 'nonpaged': 27568.0, 'virtualmem': 596426752.0, 'time': 21.027715625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3993194496.0, 'privatemem': 16967299072.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 480.1536890625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3999387648.0, 'privatemem': 16987381760.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 516.035265625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4001804288.0, 'privatemem': 17038946304.0, 'nonpaged': 23718144.0, 'virtualmem': 415501574144.0, 'time': 483.755525}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4013903872.0, 'privatemem': 17002704896.0, 'nonpaged': 23639544.0, 'virtualmem': 414158938112.0, 'time': 503.345384375}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4039008256.0, 'privatemem': 17174925312.0, 'nonpaged': 23918784.0, 'virtualmem': 419020464128.0, 'time': 505.355275}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 164077568.0, 'privatemem': 165376000.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 23.6242703125}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 136712192.0, 'privatemem': 138002432.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.1367515625}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 118976512.0, 'privatemem': 120524800.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 23.2383796875}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 127246336.0, 'privatemem': 128696320.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.4868671875}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 201854976.0, 'privatemem': 202383360.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.734434375}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4636082176.0, 'privatemem': 19810603008.0, 'nonpaged': 27575064.0, 'virtualmem': 483073843200.0, 'time': 602.0996375}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4602040320.0, 'privatemem': 19810873344.0, 'nonpaged': 27579744.0, 'virtualmem': 483141148672.0, 'time': 659.99125625}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4591165440.0, 'privatemem': 19790200832.0, 'nonpaged': 27573024.0, 'virtualmem': 483023708160.0, 'time': 583.1214046875}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4639674368.0, 'privatemem': 19800694784.0, 'nonpaged': 27572544.0, 'virtualmem': 483015319552.0, 'time': 595.6076765625}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4615213056.0, 'privatemem': 19768594432.0, 'nonpaged': 27572304.0, 'virtualmem': 483011125248.0, 'time': 585.95591875}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 122953728.0, 'privatemem': 124391424.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 22.2635234375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 128253952.0, 'privatemem': 129671168.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.54289375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 130244608.0, 'privatemem': 131567616.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 21.3423078125}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 120819712.0, 'privatemem': 121860096.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.1759359375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 197222400.0, 'privatemem': 197992448.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.0388765625}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5291032576.0, 'privatemem': 22605094912.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 769.2572203125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5268750336.0, 'privatemem': 22580580352.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 715.4761953125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5275197440.0, 'privatemem': 22597181440.0, 'nonpaged': 31506504.0, 'virtualmem': 551886561280.0, 'time': 743.6708078125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5559996416.0, 'privatemem': 22927003648.0, 'nonpaged': 31508664.0, 'virtualmem': 552185012224.0, 'time': 777.7286765625}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5265473536.0, 'privatemem': 22609494016.0, 'nonpaged': 31506384.0, 'virtualmem': 551898947584.0, 'time': 774.769990625}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 161509376.0, 'privatemem': 163639296.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 29.432303125}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 152326144.0, 'privatemem': 153423872.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 24.661028125}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 148279296.0, 'privatemem': 150319104.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 25.9785390625}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 153616384.0, 'privatemem': 154677248.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 25.02185}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 154402816.0, 'privatemem': 155430912.0, 'nonpaged': 26360.0, 'virtualmem': 573358080.0, 'time': 25.0472640625}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6044577792.0, 'privatemem': 28556054528.0, 'nonpaged': 39377064.0, 'virtualmem': 690026848256.0, 'time': 238880.438532812}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6581481472.0, 'privatemem': 28245975040.0, 'nonpaged': 39374664.0, 'virtualmem': 689695236096.0, 'time': 1124.5557}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 5939179520.0, 'privatemem': 28300779520.0, 'nonpaged': 39375144.0, 'virtualmem': 689703624704.0, 'time': 61740.7140578125}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597120000.0, 'privatemem': 28281757696.0, 'nonpaged': 39374904.0, 'virtualmem': 689728397312.0, 'time': 1146.400846875}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597758976.0, 'privatemem': 28234469376.0, 'nonpaged': 39375264.0, 'virtualmem': 689703690240.0, 'time': 1061.4835671875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 187748352.0, 'privatemem': 191131648.0, 'nonpaged': 26840.0, 'virtualmem': 581292032.0, 'time': 28.6244015625}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 186040320.0, 'privatemem': 189222912.0, 'nonpaged': 27448.0, 'virtualmem': 593874944.0, 'time': 27.09115625}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 191225856.0, 'privatemem': 192925696.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 27.2597046875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 182910976.0, 'privatemem': 184160256.0, 'nonpaged': 25760.0, 'virtualmem': 562872320.0, 'time': 26.3374671875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 178884608.0, 'privatemem': 179732480.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 26.914534375}} diff --git a/Ix++/src/cpplinq/linq.hpp b/Ix++/src/cpplinq/linq.hpp new file mode 100644 index 0000000..64cf8fb --- /dev/null +++ b/Ix++/src/cpplinq/linq.hpp @@ -0,0 +1,531 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +/// +/// namespace cpplinq +/// ----------------- +/// +/// Defines a number of range-based composable operators for enumerating and modifying collections +/// +/// The general design philosophy is to +/// (1) emulate the composable query patterns introduced in C# Linq +/// (2) preserve iterator category and writability where possible +/// For instance, like C# Linq we have a select operator to project one sequence into a new one. +/// Unlike Linq, invoking Select on a random access sequence will yield you a _random_ access sequence. +/// +/// The general workflow begins with 'from()' which normally only takes a reference +/// the the collection in question. However, from that point on, all operators function +/// by value, so that the range can store any necessary state, rather than duplicating it +/// onto iterator pairs. +/// +/// In subsequent documentation, "powers" lists which powers that the operator attempts to preserve if +/// available on on the input sequence. Some iterator powers may be skipped - in such a case, round down +/// to the next supported power (e.g. if 'fwd' and 'rnd', an input of 'bidi' will round down to a 'fwd' result). +/// +/// +/// +/// class linq_query +/// ---------------- +/// +/// from(container&) +/// ================ +/// - Result: Query +/// +/// Construct a new query, from an lvalue reference to a collection. Does not copy the collection +/// +/// +/// +/// from(iter, iter) +/// ================ +/// - Result: Query +/// +/// Construct a new query, from an iterator pair. +/// +/// +/// +/// query.select(map) +/// ========================== +/// - Result: Query +/// - Powers: input, forward, bidirectional, random access +/// +/// For each element `x` in the input sequences, computes `map(x)` for the result sequence. +/// +/// +/// +/// query.where(pred) -> query +/// ========================== +/// - Result: Query +/// - Powers: input, forward, bidirectional +/// +/// Each element `x` in the input appears in the output if `pred(x)` is true. +/// +/// The expression `pred(x)` is evaluated only when moving iterators (op++, op--). +/// Dereferencing (op*) does not invoke the predicate. +/// +/// +/// +/// query.groupby(keymap [, keyequal]) +/// ==================================== +/// Result: Query of groups. Each group has a 'key' field, and is a query of elements from the input. +/// Powers: forward +/// +/// +/// +/// query.any([pred]) +/// ================= +/// - Result: bool +/// +/// (No argument) Returns true if sequence is non-empty. Equivalent to `query.begin()!=query.end()` +/// +/// (One argument) Returns true if the sequence contains any elements for which `pred(element)` is true. +/// Equivalent to `query.where(pred).any()`. +/// +/// +/// +/// query.all(pred) +/// =============== +/// - Result: bool +/// +/// Returns true if `pred` holds for all elements in the sequence. Equivalent to `!query.any(std::not1(pred))` +/// +/// +/// +/// query.take(n) +/// ============= +/// - Result: query +/// - Powers: input, forward, random access (not bidirectional) +/// +/// Returns a sequence that contains up to `n` items from the original sequence. +/// +/// +/// +/// query.skip(n) +/// ============= +/// - Result: query +/// - Powers: input, forward, random access (not bidirectional) +/// +/// Returns a sequence that skips the first `n` items from the original sequence, or an empty sequence if +/// fewer than `n` were available on input. +/// +/// Note: begin() takes O(n) time when input iteration power is weaker than random access. +/// +/// +/// +/// query.count([pred]) +/// =================== +/// - Result: size_t +/// +/// _TODO: should use inner container's iterator distance type instead._ +/// +/// (Zero-argument) Returns the number of elements in the range. +/// Equivalent to `std::distance(query.begin(), query.end())` +/// +/// (One-argument) Returns the number of elements for whicht `pred(element)` is true. +/// Equivalent to `query.where(pred).count()` +/// + + + +#if !defined(CPPLINQ_LINQ_HPP) +#define CPPLINQ_LINQ_HPP +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + + + +// some configuration macros +#if _MSC_VER > 1600 || __cplusplus > 199711L +#define LINQ_USE_RVALUEREF 1 +#endif + +#if (defined(_MSC_VER) && _CPPRTTI) || !defined(_MSC_VER) +#define LINQ_USE_RTTI 1 +#endif + + +// individual features +#include "util.hpp" +#include "linq_cursor.hpp" +#include "linq_iterators.hpp" +#include "linq_select.hpp" +#include "linq_take.hpp" +#include "linq_skip.hpp" +#include "linq_groupby.hpp" +#include "linq_where.hpp" +#include "linq_last.hpp" +#include "linq_selectmany.hpp" + + + + +namespace cpplinq +{ + +namespace detail +{ + template + struct not1_{ + Pred pred; + not1_(Pred p) : pred(p) + {} + template + bool operator()(const T& value) + { + return !pred(value); + } + }; + // note: VC2010's std::not1 doesn't support lambda expressions. provide our own. + template + not1_ not1(Pred p) { return not1_(p); } +} + +namespace detail { + template + struct cast_to { + template + U operator()(const T& value) const { + return static_cast(value); + } + }; +} + +template +class linq_driver +{ + typedef typename Collection::cursor::element_type + element_type; + typedef typename Collection::cursor::reference_type + reference_type; +public: + typedef cursor_iterator + iterator; + + linq_driver(Collection c) : c(c) {} + + + // -------------------- linq core methods -------------------- + + template + linq_driver< linq_groupby > groupby(KeyFn fn) + { + return linq_groupby(c, std::move(fn) ); + } + + // TODO: groupby(keyfn, eq) + + // TODO: join... + + template + linq_driver< linq_select > select(Selector sel) const { + return linq_select(c, std::move(sel) ); + } + + template + linq_driver< linq_select_many > + select_many(Fn fn) const + { + return linq_select_many(c, fn, detail::default_select_many_selector()); + } + + template + linq_driver< linq_select_many > select_many(Fn fn, Fn2 fn2) const + { + return linq_select_many(c, fn, fn2); + } + + template + linq_driver< linq_where > where(Predicate p) const { + return typename linq_where(c, std::move(p) ); + } + + + // -------------------- linq peripheral methods -------------------- + + template + element_type aggregate(Fn fn) const + { + auto it = begin(); + if (it == end()) { + return element_type(); + } + + reference_type first = *it; + return std::accumulate(++it, end(), first, fn); + } + + template + T aggregate(T initialValue, Fn fn) const + { + return std::accumulate(begin(), end(), initialValue, fn); + } + + bool any() const { return !empty(cur); } + + template + bool any(Predicate p) const { + auto it = std::find_if(begin(), end(), p); + return it != end(); + } + + template + bool all(Predicate p) const { + auto it = std::find_if(begin(), end(), detail::not1(p)); + return it == end(); + } + + // TODO: average + + template + auto cast() + -> decltype(static_cast(0)->select(detail::cast_to())) + { + return this->select(detail::cast_to()); + } + + // TODO: concat + + bool contains(const typename Collection::cursor::element_type& value) const { + return std::find(begin(), end(), value) != end(); + } + + typename std::iterator_traits::distance_type count() const { + return std::distance(begin(), end()); + } + + template + typename std::iterator_traits::distance_type count(Predicate p) const { + auto filtered = this->where(p); + return std::distance(begin(filtered), end(filtered)); + } + + // TODO: default_if_empty + + // TODO: distinct() + // TODO: distinct(cmp) + + reference_type element_at(size_t ix) const { + auto cur = c.get_cursor(); + while(ix && !cur.empty()) { + cur.inc(); + --ix; + } + if (cur.empty()) { throw std::logic_error("index out of bounds"); } + else { return cur.get(); } + } + + element_type element_at_or_default(size_t ix) const { + auto cur = c.get_cursor(); + while(ix && !cur.empty()) { + cur.inc(); + -- ix; + } + if (cur.empty()) { return element_type(); } + else { return cur.get(); } + } + + bool empty() const { + return !this->any(); + } + + // TODO: except(second) + // TODO: except(second, eq) + + reference_type first() const { + auto cur = c.get_cursor(); + if (cur.empty()) { throw std::logic_error("index out of bounds"); } + else { return cur.get(); } + } + + template + reference_type first(Predicate pred) const { + auto cur = c.get_cursor(); + while (!cur.empty() && !pred(cur.get())) { + cur.inc(); + } + if (cur.empty()) { throw std::logic_error("index out of bounds"); } + else { return cur.get(); } + } + + element_type first_or_default() const { + auto cur = c.get_cursor(); + if (cur.empty()) { return element_type(); } + else { return cur.get(); } + } + + template + element_type first_or_default(Predicate pred) const { + auto cur = c.get_cursor(); + while (!cur.empty() && !pred(cur.get())) { + cur.inc(); + } + if (cur.empty()) { return element_type(); } + else { return cur.get(); } + } + + // TODO: intersect(second) + // TODO: intersect(second, eq) + + // note: forward cursors and beyond can provide a clone, so we can refer to the element directly + typename std::conditional< + std::is_convertible< + typename Collection::cursor::cursor_category, + forward_cursor_tag>::value, + reference_type, + element_type>::type + last() const + { + return linq_last_(c.get_cursor(), typename Collection::cursor::cursor_category()); + } + + template + reference_type last(Predicate pred) const + { + auto cur = c.where(pred).get_cursor(); + return linq_last_(cur, typename decltype(cur)::cursor_category()); + } + + element_type last_or_default() const + { + return linq_last_or_default_(c.get_cursor(), typename Collection::cursor::cursor_category()); + } + + template + element_type last_or_default(Predicate pred) const + { + auto cur = c.where(pred).get_cursor(); + return linq_last_or_default_(cur, typename decltype(cur)::cursor_category()); + } + + reference_type max() const + { + return max(std::less()); + } + + template + reference_type max(Compare less) const + { + auto it = std::max_element(begin(), end(), less); + if (it == end()) + throw std::logic_error("max performed on empty range"); + + return *it; + } + + reference_type min() const + { + return min(std::less()); + } + + template + reference_type min(Compare less) const + { + auto it = std::min_element(begin(), end(), less); + if (it == end()) + throw std::logic_error("max performed on empty range"); + + return *it; + } + + // TODO: order_by(sel) + // TODO: order_by(sel, less) + // TODO: order_by_descending(sel) + // TODO: order_by_descending(sel, less) + + // TODO: sequence_equal(second) + // TODO: sequence_equal(second, eq) + + // TODO: single / single_or_default + + linq_driver> skip(size_t n) const { + return linq_skip(c, n); + } + + // TODO: skip_while(pred) + + // TODO: sum + + linq_driver> take(size_t n) const { + return linq_take(c, n); + } + + // TODO: take_while + + // TODO: then_by / then_by_descending ? + + // TODO: to_... + + // TODO: union(second) + // TODO: union(eq) + + // TODO: zip + + // -------------------- conversion methods -------------------- + + std::vector to_vector() const + { + return std::vector(begin(), end()); + } + + // -------------------- container/range methods -------------------- + + iterator begin() const { return iterator(c.get_cursor()); } + iterator end() const { return iterator(); } + linq_driver& operator=(const linq_driver& other) { c = other.c; return *this; } + template + linq_driver& operator=(const linq_driver& other) { c = other.c; return *this; } + + typename std::iterator_traits::reference + operator[](size_t ix) const { + return *(begin()+=ix); + } + + // -------------------- collection methods (leaky abstraction) -------------------- + + typedef typename Collection::cursor cursor; + cursor get_cursor() { return c.get_cursor(); } + + linq_driver< dynamic_collection > + late_bind() const + { + return dynamic_collection(c); + } + +private: + Collection c; +}; + +// TODO: should probably use reference-wrapper instead? +template +linq_driver::iterator>> from(TContainer& c) +{ + auto cur = iter_cursor::iterator>(begin(c), end(c)); + return std::move(cur); +} +template +const linq_driver& from(const linq_driver& c) +{ + return c; +} +template +linq_driver> from(Iter start, Iter finish) +{ + return iter_cursor(start, finish); +} + +template +linq_driver from_value(const TContainer& c) +{ + return linq_driver(c); +} + +} + +#endif // defined(CPPLINQ_LINQ_HPP) + diff --git a/Ix++/src/cpplinq/linq_cursor.hpp b/Ix++/src/cpplinq/linq_cursor.hpp new file mode 100644 index 0000000..827c488 --- /dev/null +++ b/Ix++/src/cpplinq/linq_cursor.hpp @@ -0,0 +1,340 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_CURSOR_HPP) +#define CPPLINQ_LINQ_CURSOR_HPP +#pragma once + +/// cursors +/// ---------- +/// It should be noted that CppLinq uses a slightly different iterator concept, one where iterators +/// know their extents. This sacrificed some generality, but it adds convenience and improves +/// some performance in some cases. Notably, captures need only be stored once instead of twice in +/// most use cases. +/// +/// Cursors and Ranges are always classes. +/// +/// To get a cursor from a range: +/// +/// get_cursor(range) -> cur +/// +/// Unlike boost ranges, CppLinq cursors are mutated directly, and may "shed state" as they are +/// mutated. For example, a GroupBy range will drop references to earlier groups, possibly +/// permitting freeing them. +/// +/// Onepass cursor +/// =========== +/// - empty(cur) -> bool : at end of sequence +/// - inc(cur) +/// - get(cur) -> T +/// - copy ctor : duplicate reference to seek position +/// +/// Forward cursor +/// ============= +/// - copy ctor : true duplicate of seek position +/// +/// Bidirectional cursor +/// ==================== +/// - forget() : notes the current element as the new 'begin' point +/// - atbegin(cur) -> bool +/// - dec(cur) +/// +/// Random access cursor +/// ==================== +/// - skip(cur, n) +/// - position(cur) -> n +/// - size(cur) -> n +/// - truncate(n) : keep only n more elements +/// +/// As well, cursors must define the appropriate type/typedefs: +/// - cursor_category :: { onepass_cursor_tag, forward_cursor_tag, bidirectional_cursor_tag, random_access_cursor_tag } +/// - element_type +/// - reference_type : if writable, element_type& or such. else, == element_type +/// - + + + +namespace cpplinq { + + // used to identify cursor-based collections + struct collection_tag {}; + + struct onepass_cursor_tag {}; + struct forward_cursor_tag : onepass_cursor_tag {}; + struct bidirectional_cursor_tag : forward_cursor_tag {}; + struct random_access_cursor_tag : bidirectional_cursor_tag {}; + + struct noread_cursor_tag {}; // TODO: remove if not used + struct readonly_cursor_tag : noread_cursor_tag {}; + struct readwrite_cursor_tag : readonly_cursor_tag {}; + + + + // standard cursor adaptors + + namespace util + { + namespace detail + { + template struct type_to_size { char value[n]; }; + + type_to_size<1> get_category_from_iterator(std::input_iterator_tag); + type_to_size<2> get_category_from_iterator(std::forward_iterator_tag); + type_to_size<3> get_category_from_iterator(std::bidirectional_iterator_tag); + type_to_size<4> get_category_from_iterator(std::random_access_iterator_tag); + } + + template + struct iter_to_cursor_category_; + + template + struct iter_to_cursor_category + { + static const size_t catIx = sizeof(detail::get_category_from_iterator(typename std::iterator_traits::iterator_category()) /*.value*/ ); + typedef typename iter_to_cursor_category_::type type; + }; + + template <> struct iter_to_cursor_category_<1> { typedef onepass_cursor_tag type; }; + template <> struct iter_to_cursor_category_<2> { typedef forward_cursor_tag type; }; + template <> struct iter_to_cursor_category_<3> { typedef bidirectional_cursor_tag type; }; + template <> struct iter_to_cursor_category_<4> { typedef random_access_cursor_tag type; }; + + + // Note: returns false if no partial order exists between two + // particular iterator categories, such as with some of the boost categories + template + struct less_or_equal_cursor_category + { + private: + typedef char yes; + typedef struct { char c1,c2; } no; + static yes invoke(Cat1); + static no invoke(...); + public: + enum { value = (sizeof(invoke(Cat2())) == sizeof(yes)) }; + }; + + // Return the weaker of the two iterator categories. Make sure + // a non-standard category is in the second argument position, as + // this metafunction will default to the first value if the order is undefined + template + struct min_cursor_category : min_cursor_category::type, Cat3> + { + }; + + template + struct min_cursor_category + : std::conditional< + less_or_equal_cursor_category::value, + Cat2, + Cat1> + { + }; + + template + struct cursor_type { + typedef decltype(cursor(*static_cast(0))) type; + }; + } + + // simultaniously models a cursor and a cursor-collection + template + class iter_cursor : collection_tag { + public: + + typedef iter_cursor cursor; + + typedef typename std::remove_reference::value_type>::type + element_type; + typedef typename std::iterator_traits::reference + reference_type; + typedef typename util::iter_to_cursor_category::type + cursor_category; + + void forget() { start = current; } + bool empty() const { return current == fin; } + void inc() { + if (current == fin) + throw std::logic_error("inc past end"); + ++current; + } + typename std::iterator_traits::reference get() const { return *current; } + + bool atbegin() const { return current == start; } + void dec() { + if (current == start) + throw std::logic_error("dec past begin"); + --current; + } + + void skip(ptrdiff_t n) { current += n; } + size_t size() { return fin-start; } + void position() { return current-start; } + void truncate(size_t n) { + if (n > fin-current) { + fin = current + n; + } + } + + + iter_cursor(Iterator start, Iterator fin) + : start(start) + , fin(std::move(fin)) + , current(start) + { + } + + iter_cursor(Iterator start, Iterator fin, Iterator current) + : start(std::move(start)) + , fin(std::move(fin)) + , current(std::move(current)) + { + } + + iter_cursor get_cursor() const { return *this; } + + private: + Iterator current; + Iterator start, fin; + }; + + + template + struct cursor_interface + { + virtual bool empty() const = 0; + virtual void inc() = 0; + virtual cursor_interface* copy() const = 0; + + virtual T get() const = 0; + + virtual ~cursor_interface() {} + }; + + template + class dynamic_cursor : collection_tag + { + template + struct instance : cursor_interface + { + Cur innerCursor; + + instance(Cur cursor) : innerCursor(std::move(cursor)) + { + } + virtual bool empty() const + { + return innerCursor.empty(); + } + virtual void inc() + { + innerCursor.inc(); + } + virtual T get() const + { + return innerCursor.get(); + } + virtual cursor_interface* copy() const + { + return new instance(*this); + } + }; + + std::unique_ptr> myCur; + + public: + typedef forward_cursor_tag cursor_category; // TODO: not strictly true! + typedef typename std::remove_reference::type element_type; + typedef T reference_type; + + dynamic_cursor() {} + + dynamic_cursor(const dynamic_cursor& other) + : myCur(other.myCur ? other.myCur->copy() : nullptr) + { + } + + dynamic_cursor(dynamic_cursor&& other) + : myCur(other.myCur.release()) + { + } + + template + dynamic_cursor(Cursor cursor) + : myCur(new instance(std::move(cursor))) + { + } + + template + dynamic_cursor(Iterator start, Iterator end) + { + *this = iter_cursor(start, end); + } + + bool empty() const { return !myCur || myCur->empty(); } + void inc() { myCur->inc(); } + T get() const { return myCur->get(); } + + dynamic_cursor& operator=(dynamic_cursor other) + { + std::swap(myCur, other.myCur); + return *this; + } + }; + + template + struct container_interface + { + virtual dynamic_cursor get_cursor() const = 0; + }; + + template + class dynamic_collection + { + std::shared_ptr< container_interface > container; + + template + struct instance : container_interface + { + Container c; + + instance(Container c) : c(c) + { + } + + dynamic_cursor get_cursor() const + { + return c.get_cursor(); + } + }; + + public: + typedef dynamic_cursor cursor; + + dynamic_collection() {} + + dynamic_collection(const dynamic_collection& other) + : container(other.container) + { + } + + // container or query + template + dynamic_collection(Container c) + : container(new instance(c)) + { + } + + // container or query + template + dynamic_collection(Iterator begin, Iterator end) + : container(new instance< iter_cursor >(iter_cursor(begin, end))) + { + } + + dynamic_cursor get_cursor() const { + return container ? container->get_cursor() : dynamic_cursor(); + } + }; +} + +#endif // !defined(CPPLINQ_LINQ_CURSOR_HPP diff --git a/Ix++/src/cpplinq/linq_groupby.hpp b/Ix++/src/cpplinq/linq_groupby.hpp new file mode 100644 index 0000000..c521e5e --- /dev/null +++ b/Ix++/src/cpplinq/linq_groupby.hpp @@ -0,0 +1,195 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_GROUPBY_HPP) +#define CPPLINQ_LINQ_GROUPBY_HPP +#pragma once + +namespace cpplinq +{ + +template +struct group +{ + Key key; + Iter start; + Iter fin; + + typedef Iter iterator; + typedef Iter const_iterator; + + group(){} + + group(const Key& key) : key(key) + { + } + + Iter begin() const { return start; } + Iter end() const { return fin; } +}; + +struct default_equality +{ + template + bool operator()(const T& a, const T& b) const { + return a == b; + } +}; +struct default_less +{ + template + bool operator()(const T& a, const T& b) const { + return a < b; + } +}; + +// progressively constructs grouping as user iterates over groups and elements +// within each group. Performs this task by building a std::list of element +// iterators with equal elements within each group. +// +// invariants: +// - relative order of groups corresponds to relative order of each group's first +// element, as they appeared in the input sequence. +// - relative order of elements within a group correspond to relative order +// as they appeared in the input sequence. +// +// requires: +// Iter must be a forward iterator. +template +class linq_groupby +{ + typedef typename Collection::cursor + inner_cursor; + + typedef typename util::result_of::type + key_type; + + typedef std::list + element_list_type; + + typedef group + group_type; + + typedef std::list + group_list_type; + +private: + struct impl_t + { + // TODO: would be faster to use a chunked list, where + // pointers are invalidated but iterators are not. Need + // benchmarks first + + element_list_type elements; + std::list groups; + std::map groupIndex; + + + + KeyFn keySelector; + Compare comp; + + impl_t(inner_cursor cur, + KeyFn keySelector, + Compare comp = Compare()) + : keySelector(keySelector) + , groupIndex(comp) + { + // TODO: make lazy + insert_all(std::move(cur)); + } + + void insert_all(inner_cursor cur) + { + while(!cur.empty()) { + insert(cur.get()); + cur.inc(); + } + } + void insert(typename inner_cursor::reference_type element) + { + key_type key = keySelector(element); + auto groupPos = groupIndex.find(key); + if(groupPos == groupIndex.end()) { + // new group + bool firstGroup = groups.empty(); + + elements.push_back(element); + if(!firstGroup) { + // pop new element out of previous group + --groups.back().fin; + } + + // build new group + groups.push_back(group_type(key)); + group_type& newGroup = groups.back(); + + groupIndex.insert( std::make_pair(key, &newGroup) ); + + newGroup.fin = elements.end(); + --(newGroup.start = newGroup.fin); + } else { + // add to existing group at end + elements.insert(groupPos->second->end(), element); + } + } + }; + +public: + struct cursor { + typedef group_type + element_type; + + typedef element_type + reference_type; + + typedef forward_cursor_tag + cursor_category; + + cursor(inner_cursor cur, + KeyFn keyFn, + Compare comp = Compare()) + { + impl.reset(new impl_t(cur, keyFn, comp)); + inner = impl->groups.begin(); + fin = impl->groups.end(); + } + + void forget() { } // nop on forward-only cursors + bool empty() const { + return inner == fin; + } + void inc() { + if (inner == fin) { + throw std::logic_error("attempt to iterate past end of range"); + } + ++inner; + } + reference_type get() const { + return *inner; + } + + private: + std::shared_ptr impl; + typename std::list::iterator inner; + typename std::list::iterator fin; + }; + + linq_groupby(Collection c, + KeyFn keyFn, + Compare comp = Compare()) + : c(c), keyFn(keyFn), comp(comp) + { + } + + cursor get_cursor() const { return cursor(c.get_cursor(), keyFn, comp); } + +private: + Collection c; + KeyFn keyFn; + Compare comp; +}; + +} + +#endif // !defined(CPPLINQ_LINQ_GROUPBY_HPP) + diff --git a/Ix++/src/cpplinq/linq_iterators.hpp b/Ix++/src/cpplinq/linq_iterators.hpp new file mode 100644 index 0000000..ed267ec --- /dev/null +++ b/Ix++/src/cpplinq/linq_iterators.hpp @@ -0,0 +1,194 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_ITERATORS_HPP) +#define CPPLINQ_LINQ_ITERATORS_HPP +#pragma once + +namespace cpplinq { + + // if a member, provides the straightforward implementation of various redundant operators. For example, + // providing -> for any iterator providing *, and so forth. + struct use_default_iterator_operators {}; + + #define CPPLINQ_USE_DEFAULT_ITERATOR_OPERATORS \ + operator ::cpplinq::use_default_iterator_operators() const { return ::cpplinq::use_default_iterator_operators(); } + + template + typename std::enable_if< + std::is_convertible::value, + Iter + >::type + operator+(const Iter& it, typename std::iterator_traits::distance_type n) { + return it += n; + } + template + typename std::enable_if< + std::is_convertible::value, + Iter + >::type + operator-(const Iter& it, typename std::iterator_traits::distance_type n) { + return it -= n; + } + template + typename std::enable_if< + std::is_convertible::value, + Iter + >::type + operator-=(const Iter& it, typename std::iterator_traits::distance_type n) { + return it += (-n); + } + + template + typename std::enable_if< + std::is_convertible::value, + bool + >::type + operator!=(const Iter& it, const Iter& it2) { + return !(it == it2); + } + template + typename std::enable_if< + std::is_convertible::value, + bool + >::type + operator>(const Iter& it, const Iter& it2) { + return it2 < it; + } + template + typename std::enable_if< + std::is_convertible::value, + bool + >::type + operator<=(const Iter& it, const Iter& it2) { + return !(it2 < it); + } + template + typename std::enable_if< + std::is_convertible::value, + bool + >::type + operator>=(const Iter& it, const Iter& it2) { + return !(it < it2); + } + + namespace util { + template + typename std::iterator_traits::pointer deref_iterator(const Iter& it) { + return detail::deref_iterator(it, std::identity::reference>()); + } + + template + T* deref_iterator(const Iter& it, std::identity) { + return &*it; + } + + template + util::value_ptr deref_iterator(const Iter& it, std::identity) { + return util::value_ptr(*it); + } + } + + + template + class iter_range + { + Iter start, finish; + public: + + CPPLINQ_USE_DEFAULT_ITERATOR_OPERATORS + + typedef Iter iterator; + typedef typename iterator::value_type value_type; + + explicit iter_range(Iter start, Iter finish) : start(start), finish(finish) {} + iterator begin() const { return start; } + iterator end() const { return finish; } + }; + template + iter_range make_range(Iter start, Iter finish) { + return iter_range(start, finish); + } + + // decays into a onepass/forward iterator + template + class cursor_iterator + : public std::iterator::value, + typename std::add_pointer::type, + util::value_ptr>::type, + typename Cursor::reference_type> + { + public: + CPPLINQ_USE_DEFAULT_ITERATOR_OPERATORS; + + cursor_iterator(Cursor cur) : cur(cur) { + } + + cursor_iterator() : cur() { + } + + bool operator==(const cursor_iterator& other) const { + return !cur && !other.cur; + } + + typename Cursor::reference_type operator*() const { + return cur->get(); + } + + pointer operator->() const { + auto& v = **this; + return &v; + } + + cursor_iterator& operator++() { + cur->inc(); + + if (cur->empty()) { cur.reset(); } + return *this; + } + + cursor_iterator& operator+=(ptrdiff_t n) { + cur->skip(n); + + if (cur->empty()) { cur.reset(); } + return *this; + } + + + + private: + bool empty() const { + !cur || cur->empty(); + } + + util::maybe cur; + }; + + template + class container_range + { + Container c; + + public: + typedef cursor_iterator iterator; + + container_range(Container c) : c(c) + { + } + + iterator begin() const + { + return iterator(c.get_cursor()); + } + + iterator end() const + { + return iterator(); + } + }; + +} + +#endif diff --git a/Ix++/src/cpplinq/linq_last.hpp b/Ix++/src/cpplinq/linq_last.hpp new file mode 100644 index 0000000..fd08823 --- /dev/null +++ b/Ix++/src/cpplinq/linq_last.hpp @@ -0,0 +1,85 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_LAST_HPP) +#define CPPLINQ_LINQ_LAST_HPP +#pragma once + +namespace cpplinq { + + template + typename Cursor::element_type + linq_last_(Cursor c, onepass_cursor_tag) + { + if (c.empty()) { throw std::logic_error("last() out of bounds"); } + typename Cursor::element_type elem = c.get(); + for(;;) { + c.inc(); + if (c.empty()) break; + elem = c.get(); + } + return std::move(elem); + } + + // TODO: bidirectional iterator in constant time + + template + typename Cursor::reference_type + linq_last_(Cursor c, forward_cursor_tag) + { + if (c.empty()) { throw std::logic_error("last() out of bounds"); } + Cursor best = c; + for(;;) { + c.inc(); + if (c.empty()) break; + best = c; + } + return best.get(); + } + + template + typename Cursor::reference_type + linq_last_(Cursor c, random_access_cursor_tag) + { + if (c.empty()) { throw std::logic_error("last() out of bounds"); } + c.skip(c.size()-1); + return c.get(); + } + + template + typename Cursor::element_type + linq_last_or_default_(Cursor c, onepass_cursor_tag) + { + typename Cursor::element_type elem; + while(!c.empty()) { + elem = c.get(); + c.inc(); + } + return std::move(elem); + } + + template + typename Cursor::element_type + linq_last_or_default_(Cursor c, forward_cursor_tag) + { + if (c.empty()) { throw std::logic_error("last() out of bounds"); } + Cursor best = c; + for(;;) { + c.inc(); + if (c.empty()) break; + best = c; + } + return best.get(); + } + + template + typename Cursor::element_type + linq_last_or_default_(Cursor c, random_access_cursor_tag) + { + if (c.empty()) { return typename Cursor::element_type(); } + c.skip(c.size()-1); + return c.get(); + } + +} + +#endif // CPPLINQ_LINQ_LAST_HPP diff --git a/Ix++/src/cpplinq/linq_select.hpp b/Ix++/src/cpplinq/linq_select.hpp new file mode 100644 index 0000000..650a1dc --- /dev/null +++ b/Ix++/src/cpplinq/linq_select.hpp @@ -0,0 +1,52 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_SELECT_HPP) +#define CPPLINQ_LINQ_SELECT_HPP +#pragma once + +namespace cpplinq +{ + template + class linq_select + { + typedef typename Collection::cursor + inner_cursor; + public: + struct cursor { + typedef typename util::result_of::type + reference_type; + typedef typename std::remove_reference::type + element_type; + typedef typename inner_cursor::cursor_category + cursor_category; + + cursor(const inner_cursor& cur, Selector sel) : cur(cur), sel(std::move(sel)) {} + + void forget() { cur.forget(); } + bool empty() const { return cur.empty(); } + void inc() { cur.inc(); } + reference_type get() const { return sel(cur.get()); } + + bool atbegin() const { return cur.atbegin(); } + void dec() { cur.dec(); } + + void skip(size_t n) { cur.skip(n); } + size_t position() const { return cur.position(); } + size_t size() const { return cur.size(); } + private: + inner_cursor cur; + Selector sel; + }; + + linq_select(const Collection& c, Selector sel) : c(c), sel(sel) {} + + cursor get_cursor() const { return cursor(c.get_cursor(), sel); } + + private: + Collection c; + Selector sel; + }; + +} + +#endif // defined(CPPLINQ_LINQ_SELECT_HPP) diff --git a/Ix++/src/cpplinq/linq_selectmany.hpp b/Ix++/src/cpplinq/linq_selectmany.hpp new file mode 100644 index 0000000..45f0574 --- /dev/null +++ b/Ix++/src/cpplinq/linq_selectmany.hpp @@ -0,0 +1,107 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#include "util.hpp" +#include "linq_cursor.hpp" + +namespace cpplinq +{ + namespace detail + { + struct default_select_many_selector + { + template + auto operator()(T1&& t1, T2&& t2) const + -> decltype(std::forward(t2)) + { + return std::forward(t2); + } + }; + } + + // cur -> (T -> cur) -> cur + template + class linq_select_many + { + template static T instance(); // for type inference + + Container1 c1; + Fn fn; + Fn2 fn2; + + typedef typename Container1::cursor Cur1; + typedef decltype(from(instance()(instance().get()))) Container2; + typedef typename Container2::cursor Cur2; + + public: + class cursor + { + public: + typedef typename util::min_cursor_category::type + cursor_category; + typedef typename Cur2::reference_type reference_type; + typedef typename Cur2::element_type element_type; + + private: + // TODO: we need to lazy eval somehow, but this feels wrong. + Cur1 cur1; + dynamic_cursor cur2; + Fn fn; + Fn2 fn2; + + public: + cursor(Cur1 cur1, const Fn& fn, const Fn2& fn2) + : cur1(std::move(cur1)), fn(fn), fn2(fn2) + { + auto container2 = fn(cur1.get()); + cur2 = from(container2).get_cursor(); + } + + bool empty() const + { + return cur2.empty(); + } + + void inc() + { + cur2.inc(); + thunk(); + } + + reference_type get() const + { + return fn2(cur1.get(), cur2.get()); + } + + private: + void thunk() + { + // refill cur2 + while (cur2.empty() && !cur1.empty()) { + cur1.inc(); + if (cur1.empty()) + break; + + auto container2 = fn(cur1.get()); + cur2 = from(container2).get_cursor(); + } + } + }; + + linq_select_many(Container1 c1, Fn fn, Fn2 fn2) + : c1(std::move(c1)), fn(std::move(fn)), fn2(std::move(fn2)) + { + } + + cursor get_cursor() const + { + return cursor(c1.get_cursor(), fn, fn2); + } + }; +} + + + diff --git a/Ix++/src/cpplinq/linq_skip.hpp b/Ix++/src/cpplinq/linq_skip.hpp new file mode 100644 index 0000000..422592a --- /dev/null +++ b/Ix++/src/cpplinq/linq_skip.hpp @@ -0,0 +1,35 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_SKIP_HPP) +#define CPPLINQ_LINQ_SKIP_HPP +#pragma once + +namespace cpplinq +{ + template + struct linq_skip + { + public: + typedef typename Collection::cursor cursor; + + linq_skip(const Collection& c, size_t n) : c(c), n(n) {} + + cursor get_cursor() const { + size_t rem = n; + + auto cur = c.get_cursor(); + while(rem-- && !cur.empty()) { + cur.inc(); + } + cur.forget(); + return std::move(cur); + } + + private: + Collection c; + size_t n; + }; +} +#endif // !defined(CPPLINQ_LINQ_SKIP_HPP) + + diff --git a/Ix++/src/cpplinq/linq_take.hpp b/Ix++/src/cpplinq/linq_take.hpp new file mode 100644 index 0000000..63f7449 --- /dev/null +++ b/Ix++/src/cpplinq/linq_take.hpp @@ -0,0 +1,96 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_TAKE_HPP) +#define CPPLINQ_LINQ_TAKE_HPP +#pragma once + +namespace cpplinq +{ + template + struct linq_take_cursor + { + typedef typename InnerCursor::element_type element_type; + typedef typename InnerCursor::reference_type reference_type; + typedef typename InnerCursor::cursor_category cursor_category; + + linq_take_cursor(const InnerCursor& cur, size_t rem) : cur(cur), rem(rem) {} + + void forget() { cur.forget(); } + bool empty() const { return cur.empty() || rem == 0; } + void inc() { cur.inc(); --rem; } + reference_type get() const { return cur.get(); } + + bool atbegin() const { return cur.atbegin(); } + void dec() { cur.dec(); --rem; } + + void skip(size_t n) { cur.skip(n); rem -= n; } + size_t position() const { return cur.position(); } + size_t size() const { return cur.size(); } + + private: + InnerCursor cur; + size_t rem; + }; + + namespace detail { + template + linq_take_cursor + take_get_cursor_( + const Collection& c, + size_t n, + onepass_cursor_tag + ) + { + return linq_take_cursor(c.get_cursor(), n); + } + + template + typename Collection::cursor + take_get_cursor_( + const Collection& c, + size_t n, + random_access_cursor_tag + ) + { + auto cur = c.get_cursor(); + if (cur.size() > n) { + cur.truncate(n); + } + return std::move(cur); + } + } + + template + struct linq_take + { + typedef typename std::conditional< + util::less_or_equal_cursor_category< + random_access_cursor_tag, + typename Collection::cursor::cursor_category>::value, + typename Collection::cursor, + linq_take_cursor>::type + cursor; + + linq_take(const Collection& c, size_t n) : c(c), n(n) {} + + cursor get_cursor() const { + return detail::take_get_cursor_(c, n, typename Collection::cursor::cursor_category()); + } + + Collection c; + size_t n; + }; + + template + auto get_cursor( + const linq_take& take + ) + -> decltype(get_cursor_(take, typename Collection::cursor::cursor_category())) + { + return get_cursor_(take, typename Collection::cursor::cursor_category()); + } + + +} +#endif // !defined(CPPLINQ_LINQ_TAKE_HPP) + diff --git a/Ix++/src/cpplinq/linq_where.hpp b/Ix++/src/cpplinq/linq_where.hpp new file mode 100644 index 0000000..4f66ba7 --- /dev/null +++ b/Ix++/src/cpplinq/linq_where.hpp @@ -0,0 +1,69 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_WHERE_HPP) +#define CPPLINQ_LINQ_WHERE_HPP +#pragma once + +namespace cpplinq +{ + template + class linq_where + { + typedef typename Collection::cursor + inner_cursor; + public: + struct cursor { + typedef typename util::min_iterator_category< + bidirectional_cursor_tag, + typename inner_cursor::cursor_category>::type + cursor_category; + typedef typename inner_cursor::element_type + element_type; + typedef typename inner_cursor::reference_type + reference_type; + + cursor(const inner_cursor& cur, const Predicate& p) : cur(cur), pred(p) + { + if (!pred(cur.get())) { + this->inc(); + } + } + + void forget() { cur.forget(); } + bool empty() const { return cur.empty(); } + void inc() { + for (;;) { + cur.inc(); + if (cur.empty() || pred(cur.get())) break; + } + } + reference_type get() const { + return cur.get(); + } + + bool atbegin() const { return atbegin(cur); } + void dec() { + for (;;) { + cur.dec(); + if (pred(cur.get())) break; + } + } + private: + inner_cursor cur; + Predicate pred; + }; + + linq_where(const Collection& c, Predicate pred) : c(c), pred(pred) {} + + cursor get_cursor() const { + return cursor(c.get_cursor(), pred); + } + + private: + Collection c; + Predicate pred; + }; +} + +#endif // !defined(CPPLINQ_LINQ_WHERE_HPP) + diff --git a/Ix++/src/cpplinq/util.hpp b/Ix++/src/cpplinq/util.hpp new file mode 100644 index 0000000..6fb62ff --- /dev/null +++ b/Ix++/src/cpplinq/util.hpp @@ -0,0 +1,223 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPLINQ_LINQ_UTIL_HPP) +#define CPPLINQ_LINQ_UTIL_HPP +#pragma once + +namespace cpplinq { namespace util { + + template + struct container_traits { + typedef typename Container::iterator iterator; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::iterator_category iterator_category; + + // TODO: conservative definition for now. + enum { is_writable_iterator = + std::is_reference::reference>::value + && std::is_same::type, + typename std::remove_cv::reference>::type>::type>::value + }; + }; + + template <> + struct container_traits; + + template + struct container_traits + : container_traits + {}; + template + struct container_traits + : container_traits + { + typedef typename Container::const_iterator iterator; + }; + + // Note: returns false if no partial order exists between two + // particular iterator categories, such as with some of the boost categories + template + struct less_or_equal_iterator_category + { + private: + typedef char yes; + typedef struct { char c1,c2; } no; + static yes invoke(Cat1); + static no invoke(...); + public: + enum { value = (sizeof(invoke(Cat2())) == sizeof(yes)) }; + }; + + // Return the weaker of the two iterator categories. Make sure + // a non-standard category is in the second argument position, as + // this metafunction will default to the first value if the order is undefined + template + struct min_iterator_category + : std::conditional< + less_or_equal_iterator_category::value, + Cat2, + Cat1> + { + }; + +#if 0 +#define CppLinq_GET_ITERATOR_TYPE(TContainer) \ + decltype(begin(static_cast(0))) +#define CppLinq_GET_CONST_ITERATOR_TYPE(TContainer) \ + decltype(begin(static_cast(0))) +#else +#define CppLinq_GET_ITERATOR_TYPE(TContainer) \ + typename ::cpplinq::util::container_traits::iterator +#define CppLinq_GET_CONST_ITERATOR_TYPE(TContainer) \ + typename ::cpplinq::util::container_traits::const_iterator +#endif + + // VC10's std::tr1::result_of is busted with lambdas. use decltype instead on vc10 and later +#if defined(_MSC_VER) && _MSC_VER >= 1600 + namespace detail { + template T instance(); + }; + template struct result_of; + template + struct result_of { + typedef decltype(detail::instance()()) type; + }; + template + struct result_of { + typedef decltype(detail::instance()(detail::instance())) type; + }; + template + struct result_of { + typedef decltype(detail::instance()(detail::instance(), + detail::instance())) type; + }; + template + struct result_of { + typedef decltype(detail::instance()(detail::instance(), + detail::instance(), + detail::instance())) type; + }; + template + struct result_of { + typedef decltype(detail::instance()(detail::instance(), + detail::instance(), + detail::instance(), + detail::instance())) type; + }; +#else + template + struct result_of : std::tr1::result_of {}; +#endif + + // faux pointer proxy for iterators that dereference to a value rather than reference, such as selectors + template + struct value_ptr + { + T value; + value_ptr(const T& pvalue) : value(value) + {} + value_ptr(const T* pvalue) : value(*pvalue) + {} + const T* operator->() + { + return &value; + } + }; + + + template + class maybe + { + bool is_set; + typename std::aligned_storage::value>::type + storage; + public: + maybe() + : is_set(false) + { + } + + maybe(T value) + : is_set(false) + { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + + maybe(const maybe& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(*other.get()); + is_set = true; + } + } + maybe(maybe&& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(std::move(*other.get())); + is_set = true; + other.reset(); + } + } + + ~maybe() + { + reset(); + } + + void reset() + { + if (is_set) { + is_set = false; + reinterpret_cast(&storage)->~T(); + } + } + + T* get() { + return is_set ? reinterpret_cast(&storage) : 0; + } + + const T* get() const { + return is_set ? reinterpret_cast(&storage) : 0; + } + + void set(const T& value) { + if (is_set) { + *reinterpret_cast(&storage) = value; + } else { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + } + + T& operator*() { return *get(); } + const T& operator*() const { return *get(); } + T* operator->() { return get(); } + const T* operator->() const { return get(); } + + maybe& operator=(const T& other) { + set(other); + } + maybe& operator=(const maybe& other) { + if (const T* pother = other.get()) { + set(*pother); + } else { + reset(); + } + return *this; + } + + // boolean-like operators + operator T*() { return get(); } + operator const T*() const { return get(); } + + private: + + }; +}} + + +#endif //CPPLINQ_UTIL_HPP + diff --git a/Ix++/unittest/makefile b/Ix++/unittest/makefile new file mode 100644 index 0000000..c839943 --- /dev/null +++ b/Ix++/unittest/makefile @@ -0,0 +1,37 @@ + + +!ifndef Config +Config=Debug +!endif + +O=..\..\bin\$(Config) + +!message Building ===== $(Config) ===== + +program=testbench.exe +INCLUDE=$(INCLUDE);../ + +!if "$(Config)"=="Debug" +OPTIONS=/Od +!else +OPTIONS=/Ox +!endif +OPTIONS=$(OPTIONS) /Zi /I$(BOOST) /DBOOST_RESULT_OF_USE_DECLTYPE + +runtests : "$O/$(program)" + "$O/$(program)" + + +all : "$O/$(program)" + +$O : + mkdir $O + +"$O/$(program)" : testbench.cpp testbench.hpp ../cpplinq/*.hpp $O + $(CPP) $(OPTIONS) /EHsc /Zi /Fe"$@" /Fo$O/ testbench.cpp + +clean : + del /Q $O\*.exe + del /Q $O\*.pdb + del /Q $O\*.obj + del /Q $O\*.ilk diff --git a/Ix++/unittest/testbench.cpp b/Ix++/unittest/testbench.cpp new file mode 100644 index 0000000..7788e5f --- /dev/null +++ b/Ix++/unittest/testbench.cpp @@ -0,0 +1,527 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "cpplinq/linq.hpp" + +#include "testbench.hpp" + +using namespace std; +using namespace cpplinq; + +struct int_iter + : std::iterator +{ + int_iter(value_type i = 0, value_type step = 1) : value(i), step(step) + {} + + value_type operator*() const { + return value; + } + int_iter& operator++() { + value+=step; return *this; + } + int_iter& operator--() { + value-=step; return *this; + } + int_iter& operator+=(ptrdiff_t offset) { + value += step*offset; return *this; + } + int_iter& operator-=(ptrdiff_t offset) { + value -= step*offset; return *this; + } + ptrdiff_t operator-(int_iter rhs) const { + return ptrdiff_t((value - rhs.value)/step); + } + bool operator==(int_iter other) const { + return value == other.value; + } + bool operator!=(int_iter other) const { + return !(*this == other); + } + bool operator<(int_iter other) const { return (*this - other) < 0; } + bool operator>(int_iter other) const { return (*this - other) > 0; } + bool operator<=(int_iter other) const { return (*this - other) <= 0; } + bool operator>=(int_iter other) const { return (*this - other) >= 0; } + + value_type value; + value_type step; +}; +int_iter operator+(int_iter lhs, ptrdiff_t rhs) { + return lhs+=rhs; +} +int_iter operator+(ptrdiff_t lhs, int_iter rhs) { + return rhs+=lhs; +} +int_iter operator-(int_iter lhs, ptrdiff_t rhs) { + return lhs-=rhs; +} +struct int_range +{ + typedef int_iter iterator; + typedef int_iter::value_type value_type; + int_range(value_type begin, value_type end, value_type step = 1) + : b(begin, step), e(end, step) + { + if (step == 0) { + throw std::logic_error("bad step"); + } + if (abs(end - begin) % abs(step) != 0) { + end -= (end-begin)%abs(step); + } + } + int_iter begin() const { return int_iter(b);} + int_iter end() const { return int_iter(e); } + + iterator b, e; +}; + +vector vector_range(int start, int end) +{ + vector v; + for (int i = start; i < end; ++i) + v.push_back(i); + return v; +} + +TEST(test_selection) +{ + vector v = vector_range(0, 10); + + auto v2 = from(v) + .select([](int x) { return x*2; }); + + auto result = accumulate(begin(v2), end(v2), int(0)); + + VERIFY_EQ(90, result); +} + +TEST(test_where) +{ + vector v = vector_range(0, 10); + auto v2 = from(v) + .where([](int x) { return x % 2;}); + + VERIFY_EQ(1, *v2.begin()); + + auto result = accumulate(begin(v2), end(v2), int(0)); + + VERIFY_EQ(25, result); +} + + +bool is_prime(int x) { + if (x < 2) {return false;} + if (x == 2) {return true;} + for (int i = x/2; i >= 2; --i) { + if (x % i == 0) { return false;} + } + return true; +}; + +template +void display(It start, It end) +{ + int i = 0; + for_each(start, end, [&](typename iterator_traits::value_type x){ + if (++i % 10 == 0) { + cout << endl; + } + cout << x << " "; + }); + cout << endl; +} + +TEST(test_whereselect) +{ + auto xs = int_range(0,100); + auto ys = from(xs) + .where(is_prime) + .select([](int x){ return x*x; }); + auto result = accumulate(begin(ys), end(ys), int(0)); + + //display(begin(ys), end(ys)); + + // primes < 100 + VERIFY_EQ(65796, result); +} +TEST(test_where_modification) +{ + vector xs = vector_range(0, 100); + + auto ys = from(xs) + .where(is_prime); + std::fill(begin(ys), end(ys), int(0)); + + auto result = accumulate(begin(xs), end(xs), int(0)); + + //display(begin(ys), end(ys)); + + // non-primes < 100 + VERIFY_EQ(3890, result); +} + +TEST(test_where_any) +{ + using namespace boost::lambda; + + vector xs(200); + fill(begin(xs), end(xs), int(0)); + auto it = xs.begin(); + *it = 2; + + for(;;) { + auto last = *it++; + auto primes = from(int_range(last+1, -1)) + .where([&](int x){ + return from(begin(xs), it) + //.all([&](int d){return x%d;}); + .all(x % boost::lambda::_1); + }); + *it = *primes.begin(); + if ((*it)>=100) { + break; + } + }; + xs.erase(it, xs.end()); + + auto result = accumulate(begin(xs), end(xs), int(0)); + + //display(begin(xs), end(xs)); + + // primes < 100 + VERIFY_EQ(1060, result); +} + +TEST(test_take) +{ + auto zero_one = from(int_range(0, -1)) + .take(2); + + VERIFY_EQ(0, zero_one[0]); + VERIFY_EQ(1, zero_one[1]); + + auto ten = from(int_range(0, -1)) + .skip(10); + + VERIFY_EQ(10, ten[0]); + VERIFY_EQ(11, ten[1]); +} + +vector some_primes(size_t howMany) +{ + auto xs = from(int_range(0, -1)) + .where(is_prime) + .take(howMany); + auto v = vector(begin(xs), end(xs)); + return v; +} + +TEST(test_groupby) +{ + auto xs = some_primes(40); + //display(begin(xs), end(xs)); + + auto grouped = + from(xs) + .groupby([](int i){return i % 10; }); + + VERIFY_EQ(6, from(grouped).count()); + for(auto group = begin(grouped); group != end(grouped); ++group) { + //cout << "key = " << group->key << endl + // << "| "; + for (auto elem = group->begin(); elem != group->end(); ++elem) { + //cout << *elem << " "; + } + //cout << endl; + + switch(group->key) { + case 2: VERIFY_EQ(1, from(*group).count()); break; + case 3: VERIFY_EQ(11, from(*group).count()); break; + case 5: VERIFY_EQ(1, from(*group).count()); break; + case 7: VERIFY_EQ(11, from(*group).count()); break; + case 1: VERIFY_EQ(8, from(*group).count()); break; + case 9: VERIFY_EQ(8, from(*group).count()); break; + } + } +} + +TEST(test_symbolname) +{ + auto complexQuery = + from(int_range(0,100000)) + .select([](int x){ return x*2;}) + .where([](int x){ return x%7; }) + .skip(20); + + //cout << " type name: " << typeid(complexQuery1).name() << endl; + + + //auto complexQuery = + // complexQuery1.groupby([](int x) { return x%5; }) + // .take(3) + // ; + + + cout << "type name: " << typeid(complexQuery).name() << endl; + cout << "type name length: " << strlen(typeid(complexQuery).name()) << endl; + + auto iter = complexQuery.begin(); + cout << "iterator name: " << typeid(iter).name() << endl; + cout << "iterator name length: " << strlen(typeid(iter).name()) << endl; +} + +TEST(test_cast) +{ + auto q = from(int_range(0,10)) + .cast(); + VERIFY_EQ(false, q[0]); + VERIFY_EQ(true, q[1]); + VERIFY_EQ(true, q[2]); + VERIFY((std::is_same::value)); +} + +TEST(test_contains) +{ + auto q = from(int_range(0,10)) + .select([](int x){return x*2;}); + VERIFY(q.contains(4)); + VERIFY(!q.contains(5)); +} + +TEST(test_element_accessors) +{ + vector v(int_iter(0), int_iter(10)); + auto q = from(v) + .where([](int x){return x%2==0;}); + + VERIFY_EQ(0, q.first()); + VERIFY_EQ(8, q.last()); + VERIFY_EQ(6, q.element_at(3)); + + bool thrown = false; + try { q.element_at(5); } catch (std::logic_error&) { thrown = true; } + VERIFY(thrown); + + q.first() = 1; + q.last() = 42; + + // note: because the vector now contains { 1, 1, 2, 3, ... 7, 8, 42 }, the first + // even number is now '2' + VERIFY_EQ(2, q.first()); + VERIFY_EQ(42, q.last()); +} + +//////////////////// New style cursors //////////////////// + +TEST(test_cursor_dynamic) +{ + dynamic_cursor dc(int_iter(0), int_iter(2)); + + VERIFY(!dc.empty()); + VERIFY_EQ(0, dc.get()); + dc.inc(); + VERIFY_EQ(1, dc.get()); + dc.inc(); + VERIFY(dc.empty()); +} + +TEST(test_selectmany) +{ + int_range range1(0, 3); + auto range2 = + + from(range1) + .select_many( + [](int x) + { + return int_range(0, x+1); + }); + + auto cur = range2.get_cursor(); + + // expected: 0, 0, 1, 0, 1, 2. + VERIFY(!cur.empty()); + + VERIFY_EQ(0, cur.get()); + cur.inc(); + VERIFY(!cur.empty()); + + VERIFY_EQ(0, cur.get()); + cur.inc(); + VERIFY(!cur.empty()); + + VERIFY_EQ(1, cur.get()); + cur.inc(); + VERIFY(!cur.empty()); + + VERIFY_EQ(0, cur.get()); + cur.inc(); + VERIFY(!cur.empty()); + + VERIFY_EQ(1, cur.get()); + cur.inc(); + VERIFY(!cur.empty()); + + VERIFY_EQ(2, cur.get()); + cur.inc(); + VERIFY(cur.empty()); +} + +TEST(test_cursor_selectmany2) +{ + int_range range1(0, 3); + auto range2 = from(range1) + .select_many( + [](int x) + { + return int_range(0, x+1); + }); + + // expected: 0, 0, 1, 0, 1, 2. + int expect[] = { 0, 0, 1, 0, 1, 2 }; + + VERIFY_EQ(_countof(expect), std::distance(range2.begin(), range2.end())); + VERIFY_EQ(_countof(expect), std::distance(range2.begin(), range2.end())); + + auto result = std::mismatch(expect, expect + _countof(expect), range2.begin()); + if (result.second != range2.end()) { + cout << "mismatch: " << *result.first << " != " << *result.second << endl; + } + VERIFY( result.second == range2.end()); +} + +TEST(test_late_bind) +{ + int_range range1(0, 100); + linq_driver> range2 = from(range1).late_bind(); + + VERIFY_EQ(1, range2.element_at(1)); + + auto q1 = from(range1).select([](int x){ return x*2; }).where([](int x){ return x%10!=0; }); + + cout << "typeof q1 ==> " << typeid(q1).name() << endl; + cout << "typeof q1.late_bind() ==> " << typeid(q1.late_bind()).name() << endl; +} + +struct stopwatch +{ + time_t t0, t1; + void start() { + t1 = t0 = clock(); + } + void stop() { + t1 = clock(); + } + double value() const { + return double(t1-t0)/CLOCKS_PER_SEC; + } +}; + +template +void test_perf(Fn fn) +{ + // warmup + fn(10); + + int n = 100; + stopwatch sw; + for(;;) + { + cout << "trying n=" << n << endl; + sw.start(); + fn(n); + sw.stop(); + if (sw.value() > 2.0) { + break; + } + n *= 2; + } + cout << "time = " << sw.value() << " s\n"; + cout << "steps = " << n << "\n"; + cout << "t/step = " << (sw.value() * 1e9 / n) << " ns\n"; + cout << "step/t = " << (n / sw.value()) << " Hz\n"; +} + +TEST(test_performance) +{ + // http://projecteuler.net/problem=8 + // + // Find the greatest product of five consecutive digits in the 1000-digit number. + // + + static const char num[] = + "73167176531330624919225119674426574742355349194934" + "96983520312774506326239578318016984801869478851843" + "85861560789112949495459501737958331952853208805511" + "12540698747158523863050715693290963295227443043557" + "66896648950445244523161731856403098711121722383113" + "62229893423380308135336276614282806444486645238749" + "30358907296290491560440772390713810515859307960866" + "70172427121883998797908792274921901699720888093776" + "65727333001053367881220235421809751254540594752243" + "52584907711670556013604839586446706324415722155397" + "53697817977846174064955149290862569321978468622482" + "83972241375657056057490261407972968652414535100474" + "82166370484403199890008895243450658541227588666881" + "16427171479924442928230863465674813919123162824586" + "17866458359124566529476545682848912883142607690042" + "24219022671055626321111109370544217506941658960408" + "07198403850962455444362981230987879927244284909188" + "84580156166097919133875499200524063689912560717606" + "05886116467109405077541002256983155200055935729725" + "71636269561882670428252483600823257530420752963450"; + + auto task = [&](int n){ + for (int i = 0; i < n; ++i) { + auto range1 = int_range(0, _countof(num)-5); // 5 digit numbers, plus null terminator + + auto products = from(range1) + .select([&](int i){ return num+i;}) + .where([&](const char* s){ return !from(s, s+5).contains('0'); }) + .select([&](const char* s) { return from(s, s+5).select([](char c){ return c - '0'; }) + .aggregate(std::multiplies()); }); + + auto result = products.max(); + if (n == 1) { + cout << "result = " << result << endl; + } + } + }; + cout << "length of input: " << (_countof(num)-1) << endl; + + task(1); + cout << endl; + +#ifdef PERF + test_perf(task); + cout << endl; +#endif +} + +int main(int argc, char** argv) +{ + size_t pass=0, fail=0; + testrange<0,__LINE__>().run(pass, fail); + + + cout << "pass: " << pass << ", fail: " << fail << endl; + if (fail){ + cerr << "ERRORS PRESENT." << endl; + } else if (!pass) { + cerr << "ERROR, no tests run" << endl; + } +} diff --git a/Ix++/unittest/testbench.hpp b/Ix++/unittest/testbench.hpp new file mode 100644 index 0000000..6dbb1c8 --- /dev/null +++ b/Ix++/unittest/testbench.hpp @@ -0,0 +1,87 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#include +#include +#include +#include +#include +#include + +struct empty_testcase{ void run(){} const char* name(){return 0;} }; + +template +struct testcase : empty_testcase{}; + + +template +struct testrange { + void run(size_t& pass, size_t& fail) + { + using namespace std; + { testcase a_case; + if (a_case.name()) { + size_t p=0, f=0; + cout << "TEST: Running " << a_case.name() << endl; + try { + a_case.run(); + ++p; + } catch (logic_error& e) { + cerr << "ERRORS:" << endl; + cerr << " " << e.what() << endl; + ++f; + } + pass += p; fail += f; + } + } + const size_t rem = (end-begin-1); + testrange().run(pass, fail); + testrange().run(pass, fail); + } +}; + +template +struct testrange { + void run(size_t& pass, size_t& fail) {}; +}; + +#define TEST(fun_name) \ +void fun_name (); \ +template <> \ +struct testcase<__LINE__> { \ + const char* name() { return(#fun_name); } \ + void run() { fun_name(); } \ +}; \ +void fun_name() + +#define Q_(e) #e +#define Q(e) Q_(e) +#define TASSERT(expr) \ + { auto e = (expr); if (!e) { throw std::logic_error(__FILE__ "(" Q(__LINE__) "): TASSERT("#expr")"); } } + +struct errmsg +{ + std::shared_ptr msg; + errmsg() : msg(new std::stringstream) + {} + + template + errmsg& operator<<(T value) + { + (*msg) << value; + return *this; + } + std::string str() { return msg->str(); } +}; + +#define TEST_WHERE __FILE__ "(" Q(__LINE__) "): " +#define VERIFY(expr) \ + { auto e = (expr); if (!e) { throw std::logic_error(TEST_WHERE "VERIFY("#expr")"); } } +#define VERIFY_EQ(expected, actual) \ + { auto e = (expected); auto a = (actual); \ + if (!(e == a)) { \ + throw std::logic_error( \ + (errmsg() << TEST_WHERE << "(" << e << ")!=(" << a << ") in VERIFY_EQ("#expected","#actual")").str() );}} + + diff --git a/Ix/.gitattributes b/Ix/.gitattributes new file mode 100644 index 0000000..412eeda --- /dev/null +++ b/Ix/.gitattributes @@ -0,0 +1,22 @@ +# Auto detect text files and perform LF normalization +* text=auto + +# Custom for Visual Studio +*.cs diff=csharp +*.sln merge=union +*.csproj merge=union +*.vbproj merge=union +*.fsproj merge=union +*.dbproj merge=union + +# Standard to msysgit +*.doc diff=astextplain +*.DOC diff=astextplain +*.docx diff=astextplain +*.DOCX diff=astextplain +*.dot diff=astextplain +*.DOT diff=astextplain +*.pdf diff=astextplain +*.PDF diff=astextplain +*.rtf diff=astextplain +*.RTF diff=astextplain diff --git a/Ix/.gitignore b/Ix/.gitignore new file mode 100644 index 0000000..5ebd21a --- /dev/null +++ b/Ix/.gitignore @@ -0,0 +1,163 @@ +################# +## Eclipse +################# + +*.pydevproject +.project +.metadata +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.classpath +.settings/ +.loadpath + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# CDT-specific +.cproject + +# PDT-specific +.buildpath + + +################# +## Visual Studio +################# + +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.sln.docstates + +# Build results +[Dd]ebug/ +[Rr]elease/ +*_i.c +*_p.c +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.vspscc +.builds +*.dotCover + +## TODO: If you have NuGet Package Restore enabled, uncomment this +#packages/ + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf + +# Visual Studio profiler +*.psess +*.vsp + +# ReSharper is a .NET coding add-in +_ReSharper* + +# Installshield output folder +[Ee]xpress + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish + +# Others +[Bb]in +[Oo]bj +sql +TestResults +*.Cache +ClientBin +stylecop.* +~$* +*.dbmdl +Generated_Code #added for RIA/Silverlight projects + +# Backup & report files from converting an old project file to a newer +# Visual Studio version. Backup files are not needed, because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML + + + +############ +## Windows +############ + +# Windows image file caches +Thumbs.db + +# Folder config file +Desktop.ini + + +############# +## Python +############# + +*.py[co] + +# Packages +*.egg +*.egg-info +dist +build +eggs +parts +bin +var +sdist +develop-eggs +.installed.cfg + +# Installer logs +pip-log.txt + +# Unit test / coverage reports +.coverage +.tox + +#Translations +*.mo + +#Mr Developer +.mr.developer.cfg + +# Mac crap +.DS_Store diff --git a/Ix/Common.targets b/Ix/Common.targets new file mode 100644 index 0000000..032880f --- /dev/null +++ b/Ix/Common.targets @@ -0,0 +1,180 @@ + + + + + AnyCPU + 8.0.30703 + 2.0 + + + + + true + full + false + bin\Debug40\ + $(DefineConstants);TRACE;DEBUG + prompt + 4 + v4.0 + DESKTOPCLR + DESKTOPCLR40 + + + pdbonly + true + bin\Release40\ + $(DefineConstants);TRACE + prompt + 4 + v4.0 + DESKTOPCLR + DESKTOPCLR40 + + + + true + full + false + bin\Debug35\ + $(DefineConstants);TRACE;DEBUG;NO_VARIANCE;NO_TPL;NO_LARGEARITY;NO_RXINTERFACES;NO_ZIP + prompt + 4 + v3.5 + DESKTOPCLR + DESKTOPCLR20 + + + pdbonly + true + bin\Release35\ + $(DefineConstants);TRACE;NO_VARIANCE;NO_TPL;NO_LARGEARITY;NO_RXINTERFACES;NO_ZIP + prompt + 4 + v3.5 + DESKTOPCLR + DESKTOPCLR20 + + + + true + full + false + bin\DebugSL4\ + $(DefineConstants);TRACE;DEBUG;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES + prompt + 4 + Silverlight + v4.0 + $(TargetFrameworkVersion) + false + SILVERLIGHT + SILVERLIGHT4 + + + pdbonly + true + bin\ReleaseSL4\ + $(DefineConstants);TRACE;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES + prompt + 4 + Silverlight + v4.0 + $(TargetFrameworkVersion) + false + SILVERLIGHT + SILVERLIGHT4 + + + true + full + false + bin\DebugSL5\ + $(DefineConstants);TRACE;DEBUG;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES + prompt + 4 + Silverlight + v5.0 + $(TargetFrameworkVersion) + false + SILVERLIGHT + SILVERLIGHT5 + + + pdbonly + true + bin\ReleaseSL5\ + $(DefineConstants);TRACE;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES + prompt + 4 + Silverlight + v5.0 + $(TargetFrameworkVersion) + false + SILVERLIGHT + SILVERLIGHT5 + + + + true + full + false + bin\DebugWP7\ + $(DefineConstants);TRACE;DEBUG;WINDOWSPHONE7;NO_TLS;NO_VARIANCE;NO_SERIALIZABLE;NO_TPL;NO_HASHSET;NO_REMOTING;NO_SEMAPHORE;NO_LARGEARITY;NO_ZIP + prompt + 4 + WindowsPhone + Silverlight + v4.0 + $(TargetFrameworkVersion) + false + SILVERLIGHT + SILVERLIGHTM7 + + + pdbonly + true + bin\ReleaseWP7\ + $(DefineConstants);TRACE;WINDOWSPHONE7;NO_TLS;NO_VARIANCE;NO_SERIALIZABLE;NO_TPL;NO_HASHSET;NO_REMOTING;NO_SEMAPHORE;NO_LARGEARITY;NO_ZIP + prompt + 4 + WindowsPhone + Silverlight + v4.0 + $(TargetFrameworkVersion) + false + SILVERLIGHT + SILVERLIGHTM7 + + + + $(DefineConstants);$(BuildPlatform);$(BuildFlavor) + + + + $(DefineConstants);STABLE + + + + $(DefineConstants);SIGNED + true + ..\35MSSharedLib1024.snk + true + + + + $(DefineConstants);NO_CODECOVERAGE + + + + CP_SetBuildReferencePath + + + + $(ProjectDir)..\..\..\References\$(BuildFlavor) + + + + \ No newline at end of file diff --git a/Ix/Import.targets b/Ix/Import.targets new file mode 100644 index 0000000..fb23483 --- /dev/null +++ b/Ix/Import.targets @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/Ix/Interactive Extensions.sln b/Ix/Interactive Extensions.sln new file mode 100644 index 0000000..5fbfed0 --- /dev/null +++ b/Ix/Interactive Extensions.sln @@ -0,0 +1,332 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Interactive", "System.Interactive\System.Interactive.csproj", "{8E4B04F0-915E-48F9-9796-76278C6094BD}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{C4C8532A-F8D2-428B-962E-FD578A1E647C}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{01E445E3-2296-48ED-A70D-F64CE755E0B6}" + ProjectSection(SolutionItems) = preProject + Interactive Extensions.vsmdi = Interactive Extensions.vsmdi + Local.testsettings = Local.testsettings + TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings + EndProjectSection +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Interactive.Providers", "System.Interactive.Providers\System.Interactive.Providers.csproj", "{6D62E966-469D-4A99-BD43-0A17FA14FB4F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Interactive.Async", "System.Interactive.Async\System.Interactive.Async.csproj", "{7269A578-326A-4C3E-9874-A2D2600095BC}" +EndProject +Global + GlobalSection(TestCaseManagementSettings) = postSolution + CategoryFile = Interactive Extensions.vsmdi + EndGlobalSection + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|Mixed Platforms = Debug|Mixed Platforms + Debug|x86 = Debug|x86 + Debug35|Any CPU = Debug35|Any CPU + Debug35|Mixed Platforms = Debug35|Mixed Platforms + Debug35|x86 = Debug35|x86 + Debug40|Any CPU = Debug40|Any CPU + Debug40|Mixed Platforms = Debug40|Mixed Platforms + Debug40|x86 = Debug40|x86 + DebugPL|Any CPU = DebugPL|Any CPU + DebugPL|Mixed Platforms = DebugPL|Mixed Platforms + DebugPL|x86 = DebugPL|x86 + DebugSL4|Any CPU = DebugSL4|Any CPU + DebugSL4|Mixed Platforms = DebugSL4|Mixed Platforms + DebugSL4|x86 = DebugSL4|x86 + DebugSL5|Any CPU = DebugSL5|Any CPU + DebugSL5|Mixed Platforms = DebugSL5|Mixed Platforms + DebugSL5|x86 = DebugSL5|x86 + DebugWP7|Any CPU = DebugWP7|Any CPU + DebugWP7|Mixed Platforms = DebugWP7|Mixed Platforms + DebugWP7|x86 = DebugWP7|x86 + Release|Any CPU = Release|Any CPU + Release|Mixed Platforms = Release|Mixed Platforms + Release|x86 = Release|x86 + Release35|Any CPU = Release35|Any CPU + Release35|Mixed Platforms = Release35|Mixed Platforms + Release35|x86 = Release35|x86 + Release40|Any CPU = Release40|Any CPU + Release40|Mixed Platforms = Release40|Mixed Platforms + Release40|x86 = Release40|x86 + ReleasePL|Any CPU = ReleasePL|Any CPU + ReleasePL|Mixed Platforms = ReleasePL|Mixed Platforms + ReleasePL|x86 = ReleasePL|x86 + ReleaseSL4|Any CPU = ReleaseSL4|Any CPU + ReleaseSL4|Mixed Platforms = ReleaseSL4|Mixed Platforms + ReleaseSL4|x86 = ReleaseSL4|x86 + ReleaseSL5|Any CPU = ReleaseSL5|Any CPU + ReleaseSL5|Mixed Platforms = ReleaseSL5|Mixed Platforms + ReleaseSL5|x86 = ReleaseSL5|x86 + ReleaseWP7|Any CPU = ReleaseWP7|Any CPU + ReleaseWP7|Mixed Platforms = ReleaseWP7|Mixed Platforms + ReleaseWP7|x86 = ReleaseWP7|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Any CPU.ActiveCfg = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Any CPU.Build.0 = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Mixed Platforms.ActiveCfg = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Mixed Platforms.Build.0 = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|x86.ActiveCfg = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Any CPU.Build.0 = Debug35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Mixed Platforms.Build.0 = Debug35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|x86.ActiveCfg = Debug35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Any CPU.Build.0 = Debug40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|x86.ActiveCfg = Debug40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Any CPU.ActiveCfg = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Any CPU.Build.0 = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Mixed Platforms.ActiveCfg = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Mixed Platforms.Build.0 = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|x86.ActiveCfg = DebugPL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Any CPU.Build.0 = DebugSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Mixed Platforms.Build.0 = DebugSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Any CPU.Build.0 = DebugSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Mixed Platforms.Build.0 = DebugSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Any CPU.Build.0 = DebugWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Mixed Platforms.Build.0 = DebugWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Any CPU.ActiveCfg = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Any CPU.Build.0 = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Mixed Platforms.Build.0 = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|x86.ActiveCfg = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Any CPU.ActiveCfg = Release35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Any CPU.Build.0 = Release35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Mixed Platforms.Build.0 = Release35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|x86.ActiveCfg = Release35|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Any CPU.ActiveCfg = Release40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Any CPU.Build.0 = Release40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|x86.ActiveCfg = Release40|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Any CPU.ActiveCfg = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Any CPU.Build.0 = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Mixed Platforms.Build.0 = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|x86.ActiveCfg = ReleasePL|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Any CPU.Build.0 = ReleaseSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Mixed Platforms.Build.0 = ReleaseSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Any CPU.Build.0 = ReleaseSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Mixed Platforms.Build.0 = ReleaseSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Any CPU.Build.0 = ReleaseWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU + {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Any CPU.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Any CPU.Build.0 = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Mixed Platforms.Build.0 = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|x86.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Any CPU.Build.0 = Debug35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Mixed Platforms.Build.0 = Debug35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|x86.ActiveCfg = Debug35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Any CPU.Build.0 = Debug40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|x86.ActiveCfg = Debug40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Any CPU.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Any CPU.Build.0 = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Mixed Platforms.Build.0 = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|x86.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Any CPU.Build.0 = DebugSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Mixed Platforms.Build.0 = DebugSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Any CPU.Build.0 = DebugSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Mixed Platforms.Build.0 = DebugSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Any CPU.Build.0 = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Mixed Platforms.Build.0 = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Any CPU.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Any CPU.Build.0 = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|x86.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Any CPU.ActiveCfg = Release35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Any CPU.Build.0 = Release35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Mixed Platforms.Build.0 = Release35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|x86.ActiveCfg = Release35|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Any CPU.ActiveCfg = Release40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Any CPU.Build.0 = Release40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|x86.ActiveCfg = Release40|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Any CPU.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Any CPU.Build.0 = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|x86.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Any CPU.Build.0 = ReleaseSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Mixed Platforms.Build.0 = ReleaseSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Any CPU.Build.0 = ReleaseSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Mixed Platforms.Build.0 = ReleaseSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Any CPU.Build.0 = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU + {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Any CPU.ActiveCfg = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Any CPU.Build.0 = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Mixed Platforms.ActiveCfg = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Mixed Platforms.Build.0 = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|x86.ActiveCfg = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Any CPU.Build.0 = Debug35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Mixed Platforms.Build.0 = Debug35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|x86.ActiveCfg = Debug35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Any CPU.Build.0 = Debug40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|x86.ActiveCfg = Debug40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Any CPU.ActiveCfg = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Any CPU.Build.0 = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Mixed Platforms.ActiveCfg = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Mixed Platforms.Build.0 = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|x86.ActiveCfg = DebugPL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Any CPU.Build.0 = DebugSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Mixed Platforms.Build.0 = DebugSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Any CPU.Build.0 = DebugSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Mixed Platforms.Build.0 = DebugSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Any CPU.ActiveCfg = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Any CPU.Build.0 = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Mixed Platforms.Build.0 = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|x86.ActiveCfg = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Any CPU.ActiveCfg = Release35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Any CPU.Build.0 = Release35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Mixed Platforms.Build.0 = Release35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|x86.ActiveCfg = Release35|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Any CPU.ActiveCfg = Release40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Any CPU.Build.0 = Release40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|x86.ActiveCfg = Release40|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Any CPU.ActiveCfg = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Any CPU.Build.0 = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Mixed Platforms.Build.0 = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|x86.ActiveCfg = ReleasePL|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Any CPU.Build.0 = ReleaseSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Mixed Platforms.Build.0 = ReleaseSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Any CPU.Build.0 = ReleaseSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Mixed Platforms.Build.0 = ReleaseSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU + {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Any CPU.ActiveCfg = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Any CPU.Build.0 = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Mixed Platforms.ActiveCfg = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Mixed Platforms.Build.0 = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|x86.ActiveCfg = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug35|x86.ActiveCfg = Debug35|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Any CPU.Build.0 = Debug40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|x86.ActiveCfg = Debug40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Any CPU.ActiveCfg = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Any CPU.Build.0 = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Mixed Platforms.ActiveCfg = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Mixed Platforms.Build.0 = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|x86.ActiveCfg = DebugPL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Any CPU.ActiveCfg = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Any CPU.Build.0 = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Mixed Platforms.Build.0 = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|x86.ActiveCfg = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release35|Any CPU.ActiveCfg = Release35|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release35|x86.ActiveCfg = Release35|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Any CPU.ActiveCfg = Release40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Any CPU.Build.0 = Release40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|x86.ActiveCfg = Release40|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Any CPU.ActiveCfg = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Any CPU.Build.0 = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Mixed Platforms.Build.0 = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|x86.ActiveCfg = ReleasePL|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU + {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Ix/Interactive Extensions.vsmdi b/Ix/Interactive Extensions.vsmdi new file mode 100644 index 0000000..3031d67 --- /dev/null +++ b/Ix/Interactive Extensions.vsmdi @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Ix/Interactive Extensions.vssscc b/Ix/Interactive Extensions.vssscc new file mode 100644 index 0000000..6cb031b --- /dev/null +++ b/Ix/Interactive Extensions.vssscc @@ -0,0 +1,10 @@ +"" +{ +"FILE_VERSION" = "9237" +"ENLISTMENT_CHOICE" = "NEVER" +"PROJECT_FILE_RELATIVE_PATH" = "" +"NUMBER_OF_EXCLUDED_FILES" = "0" +"ORIGINAL_PROJECT_FILE_PATH" = "" +"NUMBER_OF_NESTED_PROJECTS" = "0" +"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT" +} diff --git a/Ix/Local.testsettings b/Ix/Local.testsettings new file mode 100644 index 0000000..9c078dd --- /dev/null +++ b/Ix/Local.testsettings @@ -0,0 +1,37 @@ + + + These are default test settings for a local test run. + + + + + + + + + + +
+
+
+
+ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs new file mode 100644 index 0000000..8b0f766 --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs @@ -0,0 +1,2019 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Threading; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator, Func resultSelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + var tcs = new TaskCompletionSource(); + + var acc = seed; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + acc = accumulator(acc, e.Current); + f(ct); + } + catch (Exception exception) + { + tcs.TrySetException(exception); + } + } + else + { + var result = default(TResult); + try + { + result = resultSelector(acc); + } + catch (Exception exception) + { + tcs.TrySetException(exception); + return; + } + + tcs.TrySetResult(result); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return source.Aggregate(seed, accumulator, x => x, cancellationToken); + } + + public static Task Aggregate(this IAsyncEnumerable source, Func accumulator, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + var tcs = new TaskCompletionSource(); + + var first = true; + var acc = default(TSource); + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + if (first) + acc = e.Current; + else + acc = accumulator(acc, e.Current); + f(ct); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + } + + first = false; + } + else + { + if (first) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(acc); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Count(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0, (c, _) => c + 1, cancellationToken); + } + + public static Task Count(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).Aggregate(0, (c, _) => c + 1, cancellationToken); + } + + public static Task LongCount(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0L, (c, _) => c + 1, cancellationToken); + } + + public static Task LongCount(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).Aggregate(0L, (c, _) => c + 1, cancellationToken); + } + + public static Task All(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + if (!predicate(e.Current)) + tcs.TrySetResult(false); + else + f(ct); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + } + } + else + { + tcs.TrySetResult(true); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Any(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + if (predicate(e.Current)) + tcs.TrySetResult(true); + else + f(ct); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + } + } + else + { + tcs.TrySetResult(false); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Any(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var e = source.GetEnumerator(); + return e.MoveNext(cancellationToken); + } + + public static Task Contains(this IAsyncEnumerable source, TSource value, IEqualityComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Any(x => comparer.Equals(x, value), cancellationToken); + } + + public static Task Contains(this IAsyncEnumerable source, TSource value, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Contains(value, EqualityComparer.Default, cancellationToken); + } + + public static Task First(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + e.MoveNext(cancellationToken).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + tcs.TrySetResult(e.Current); + else + tcs.TrySetException(new InvalidOperationException()); + }); + }); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task First(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).First(cancellationToken); + } + + public static Task FirstOrDefault(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + e.MoveNext(cancellationToken).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + tcs.TrySetResult(e.Current); + else + tcs.TrySetResult(default(TSource)); + }); + }); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task FirstOrDefault(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).FirstOrDefault(cancellationToken); + } + + public static Task Last(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + var last = default(TSource); + var hasLast = false; + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + hasLast = true; + last = e.Current; + f(ct); + } + else + { + if (!hasLast) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(last); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Last(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).Last(cancellationToken); + } + + public static Task LastOrDefault(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + var last = default(TSource); + var hasLast = false; + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + hasLast = true; + last = e.Current; + f(ct); + } + else + { + if (!hasLast) + tcs.TrySetResult(default(TSource)); + else + tcs.TrySetResult(last); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task LastOrDefault(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).LastOrDefault(cancellationToken); + } + + public static Task Single(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + e.MoveNext(cancellationToken).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var result = e.Current; + e.MoveNext(cancellationToken).ContinueWith(t1 => + { + t1.Handle(tcs, res1 => + { + if (res1) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(result); + }); + }); + } + else + tcs.TrySetException(new InvalidOperationException()); + }); + }); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Single(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).Single(cancellationToken); + } + + public static Task SingleOrDefault(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + e.MoveNext(cancellationToken).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var result = e.Current; + e.MoveNext(cancellationToken).ContinueWith(t1 => + { + t1.Handle(tcs, res1 => + { + if (res1) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(result); + }); + }); + } + else + tcs.TrySetResult(default(TSource)); + }); + }); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task SingleOrDefault(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return source.Where(predicate).SingleOrDefault(cancellationToken); + } + + public static Task ElementAt(this IAsyncEnumerable source, int index, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (index < 0) + throw new ArgumentOutOfRangeException("index"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + var next = default(Action); + next = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (index == 0) + { + tcs.TrySetResult(e.Current); + } + else + { + index--; + next(ct); + } + } + else + { + tcs.TrySetException(new ArgumentOutOfRangeException()); + } + }); + }); + + next(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task ElementAtOrDefault(this IAsyncEnumerable source, int index, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (index < 0) + throw new ArgumentOutOfRangeException("index"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + var next = default(Action); + next = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (index == 0) + { + tcs.TrySetResult(e.Current); + } + else + { + index--; + next(ct); + } + } + else + { + tcs.TrySetResult(default(TSource)); + } + }); + }); + + next(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task ToArray(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(new List(), (list, x) => { list.Add(x); return list; }, list => list.ToArray(), cancellationToken); + } + + public static Task> ToList(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(new List(), (list, x) => { list.Add(x); return list; }, cancellationToken); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Aggregate(new Dictionary(comparer), (d, x) => { d.Add(keySelector(x), elementSelector(x)); return d; }, cancellationToken); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + + return source.ToDictionary(keySelector, elementSelector, EqualityComparer.Default, cancellationToken); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.ToDictionary(keySelector, x => x, comparer, cancellationToken); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.ToDictionary(keySelector, x => x, EqualityComparer.Default, cancellationToken); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Aggregate(new Lookup(comparer), (lookup, x) => { lookup.Add(keySelector(x), elementSelector(x)); return lookup; }, lookup => (ILookup)lookup, cancellationToken); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + + return source.ToLookup(keySelector, elementSelector, EqualityComparer.Default, cancellationToken); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.ToLookup(keySelector, x => x, comparer, cancellationToken); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.ToLookup(keySelector, x => x, EqualityComparer.Default, cancellationToken); + } + + class Lookup : ILookup + { + private readonly Dictionary> map; + + public Lookup(IEqualityComparer comparer) + { + map = new Dictionary>(comparer); + } + + public void Add(TKey key, TElement element) + { + var g = default(EnumerableGrouping); + if (!map.TryGetValue(key, out g)) + { + g = new EnumerableGrouping(key); + map.Add(key, g); + } + + g.Add(element); + } + + public bool Contains(TKey key) + { + return map.ContainsKey(key); + } + + public int Count + { + get { return map.Keys.Count; } + } + + public IEnumerable this[TKey key] + { + get { return map[key]; } + } + + public IEnumerator> GetEnumerator() + { + return map.Values.Cast>().GetEnumerator(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0.0; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + count++; + sum += e.Current; + f(ct); + } + else + { + if (count == 0) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0.0; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (e.Current.HasValue) + { + count++; + sum += e.Current.Value; + } + f(ct); + } + else + { + if (count == 0) + tcs.TrySetResult(null); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0.0; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + count++; + sum += e.Current; + f(ct); + } + else + { + if (count == 0) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0.0; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (e.Current.HasValue) + { + count++; + sum += e.Current.Value; + } + f(ct); + } + else + { + if (count == 0) + tcs.TrySetResult(null); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0.0; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + count++; + sum += e.Current; + f(ct); + } + else + { + if (count == 0) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0.0; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (e.Current.HasValue) + { + count++; + sum += e.Current.Value; + } + f(ct); + } + else + { + if (count == 0) + tcs.TrySetResult(null); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0f; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + count++; + sum += e.Current; + f(ct); + } + else + { + if (count == 0) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0f; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (e.Current.HasValue) + { + count++; + sum += e.Current.Value; + } + f(ct); + } + else + { + if (count == 0) + tcs.TrySetResult(null); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0m; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + count++; + sum += e.Current; + f(ct); + } + else + { + if (count == 0) + tcs.TrySetException(new InvalidOperationException()); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var tcs = new TaskCompletionSource(); + + var count = 0L; + var sum = 0m; + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (e.Current.HasValue) + { + count++; + sum += e.Current.Value; + } + f(ct); + } + else + { + if (count == 0) + tcs.TrySetResult(null); + else + tcs.TrySetResult(sum / count); + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Average(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Max, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Max, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Max, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Max, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Max, cancellationToken); + } + + static T? NullableMax(T? x, T? y) + where T : struct, IComparable + { + if (!x.HasValue) + return y; + if (!y.HasValue) + return x; + if (x.Value.CompareTo(y.Value) >= 0) + return x; + return y; + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(int?), NullableMax, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(long?), NullableMax, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(double?), NullableMax, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(float?), NullableMax, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(decimal?), NullableMax, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var comparer = Comparer.Default; + return source.Aggregate((x, y) => comparer.Compare(x, y) >= 0 ? x : y, cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Max(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Min, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Min, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Min, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Min, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(Math.Min, cancellationToken); + } + + static T? NullableMin(T? x, T? y) + where T : struct, IComparable + { + if (!x.HasValue) + return y; + if (!y.HasValue) + return x; + if (x.Value.CompareTo(y.Value) <= 0) + return x; + return y; + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(int?), NullableMin, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(long?), NullableMin, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(double?), NullableMin, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(float?), NullableMin, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(default(decimal?), NullableMin, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + var comparer = Comparer.Default; + return source.Aggregate((x, y) => comparer.Compare(x, y) <= 0 ? x : y, cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Min(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0, (x, y) => x + y, cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0L, (x, y) => x + y, cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0.0, (x, y) => x + y, cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0f, (x, y) => x + y, cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate(0m, (x, y) => x + y, cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate((int?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate((long?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate((double?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate((float?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Aggregate((decimal?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Select(selector).Sum(cancellationToken); + } + + public static Task IsEmpty(this IAsyncEnumerable source, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Any(cancellationToken).ContinueWith(t => !t.Result); + } + + public static Task Min(this IAsyncEnumerable source, IComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return MinBy(source, x => x, comparer, cancellationToken).ContinueWith(t => t.Result.First()); + } + + public static Task> MinBy(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return MinBy(source, keySelector, Comparer.Default, cancellationToken); + } + + public static Task> MinBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ExtremaBy(source, keySelector, (key, minValue) => -comparer.Compare(key, minValue), cancellationToken); + } + + public static Task Max(this IAsyncEnumerable source, IComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return MaxBy(source, x => x, comparer, cancellationToken).ContinueWith(t => t.Result.First()); + } + + public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return MaxBy(source, keySelector, Comparer.Default, cancellationToken); + } + + public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ExtremaBy(source, keySelector, (key, minValue) => comparer.Compare(key, minValue), cancellationToken); + } + + private static Task> ExtremaBy(IAsyncEnumerable source, Func keySelector, Func compare, CancellationToken cancellationToken) + { + var tcs = new TaskCompletionSource>(); + + var result = new List(); + + var hasFirst = false; + var current = default(TSource); + var resKey = default(TKey); + + var e = source.GetEnumerator(); + + var f = default(Action); + f = ct => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (!hasFirst) + { + if (!res) + { + tcs.TrySetException(new InvalidOperationException("Source sequence doesn't contain any elements.")); + return; + } + + current = e.Current; + + try + { + resKey = keySelector(current); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + result.Add(current); + + hasFirst = true; + f(ct); + } + else + { + if (res) + { + var key = default(TKey); + var cmp = default(int); + + try + { + current = e.Current; + key = keySelector(current); + cmp = compare(key, resKey); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (cmp == 0) + { + result.Add(current); + } + else if (cmp > 0) + { + result = new List { current }; + resKey = key; + } + + f(ct); + } + else + { + tcs.TrySetResult(result); + } + } + }); + }); + + f(cancellationToken); + + return tcs.Task.Finally(e.Dispose); + } + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs new file mode 100644 index 0000000..2c66eec --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs @@ -0,0 +1,262 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Threading; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + public static IAsyncEnumerable ToAsyncEnumerable(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Create(() => + { + var e = source.GetEnumerator(); + + return Create( + ct => Task.Factory.StartNew(() => + { + var res = default(bool); + try + { + res = e.MoveNext(); + } + finally + { + if (!res) + e.Dispose(); + } + return res; + }, ct), + () => e.Current, + () => e.Dispose() + ); + }); + } + + public static IEnumerable ToEnumerable(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return ToEnumerable_(source); + } + + private static IEnumerable ToEnumerable_(IAsyncEnumerable source) + { + using (var e = source.GetEnumerator()) + { + while (true) + { + var t = e.MoveNext(CancellationToken.None); + t.Wait(); + if (!t.Result) + break; + var c = e.Current; + yield return c; + } + } + } + +#if !NO_RXINTERFACES + public static IAsyncEnumerable ToAsyncEnumerable(this IObservable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Create(() => + { + var observer = new ToAsyncEnumerableObserver(); + observer.Queue = new Queue>(); + + var subscription = source.Subscribe(observer); + + return Create( + (ct, tcs) => + { + lock (observer.Queue) + { + if (observer.Queue.Count > 0) + { + var n = observer.Queue.Dequeue(); + n.Switch( + x => + { + observer.Current = x; + tcs.TrySetResult(true); + }, + ex => + { + tcs.TrySetException(ex); + }, + _ => + { + tcs.TrySetResult(false); + } + ); + } + else + observer.TaskCompletionSource = tcs; + } + + return tcs.Task; + }, + () => observer.Current, + () => + { + subscription.Dispose(); + // Should we cancel in-flight operations somehow? + }); + }); + } + + class ToAsyncEnumerableObserver : IObserver + { + public Queue> Queue { get; set; } + public T Current { get; set; } + public TaskCompletionSource TaskCompletionSource { get; set; } + + public void OnCompleted() + { + lock (Queue) + { + if (TaskCompletionSource == null) + Queue.Enqueue(new Either.Choice3(true)); + else + { + TaskCompletionSource.SetResult(false); + TaskCompletionSource = null; + } + } + } + + public void OnError(Exception error) + { + lock (Queue) + { + if (TaskCompletionSource == null) + Queue.Enqueue(new Either.Choice2(error)); + else + { + TaskCompletionSource.SetException(error); + TaskCompletionSource = null; + } + } + } + + public void OnNext(T value) + { + lock (Queue) + { + if (TaskCompletionSource == null) + Queue.Enqueue(new Either.Choice1(value)); + else + { + Current = value; + TaskCompletionSource.SetResult(true); + TaskCompletionSource = null; + } + } + } + } + + abstract class Either + { + public abstract void Switch(Action choice1, Action choice2, Action choice3); + + public class Choice1 : Either + { + public Choice1(T value) { Value = value; } + public T Value { get; private set; } + + public override void Switch(Action choice1, Action choice2, Action choice3) + { + choice1(Value); + } + } + + public class Choice2 : Either + { + public Choice2(U value) { Value = value; } + public U Value { get; private set; } + + public override void Switch(Action choice1, Action choice2, Action choice3) + { + choice2(Value); + } + } + + public class Choice3 : Either + { + public Choice3(V value) { Value = value; } + public V Value { get; private set; } + + public override void Switch(Action choice1, Action choice2, Action choice3) + { + choice3(Value); + } + } + } + + public static IObservable ToObservable(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return new ToObservableObservable(source); + } + + class ToObservableObservable : IObservable + { + private readonly IAsyncEnumerable source; + + public ToObservableObservable(IAsyncEnumerable source) + { + this.source = source; + } + + public IDisposable Subscribe(IObserver observer) + { + var ctd = new CancellationTokenDisposable(); + var e = source.GetEnumerator(); + + var f = default(Action); + f = () => e.MoveNext(ctd.Token).ContinueWith(t => + { + if (t.IsFaulted) + { + observer.OnError(t.Exception); + e.Dispose(); + } + else if (t.IsCanceled) + { + e.Dispose(); + } + else if (t.IsCompleted) + { + if (t.Result) + { + observer.OnNext(e.Current); + f(); + } + else + { + observer.OnCompleted(); + e.Dispose(); + } + } + }, ctd.Token); + + f(); + + return new CompositeDisposable(ctd, e); + } + } +#endif + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs new file mode 100644 index 0000000..f930293 --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs @@ -0,0 +1,283 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + static IAsyncEnumerable Create(Func> getEnumerator) + { + return new AnonymousAsyncEnumerable(getEnumerator); + } + + class AnonymousAsyncEnumerable : IAsyncEnumerable + { + Func> getEnumerator; + + public AnonymousAsyncEnumerable(Func> getEnumerator) + { + this.getEnumerator = getEnumerator; + } + + public IAsyncEnumerator GetEnumerator() + { + return getEnumerator(); + } + } + + static IAsyncEnumerator Create(Func> moveNext, Func current, Action dispose) + { + return new AnonymousAsyncEnumerator(moveNext, current, dispose); + } + + static IAsyncEnumerator Create(Func, Task> moveNext, Func current, Action dispose) + { + var self = default(IAsyncEnumerator); + self = new AnonymousAsyncEnumerator( + ct => + { + var tcs = new TaskCompletionSource(); + + var stop = new Action(() => + { + self.Dispose(); + tcs.TrySetCanceled(); + }); + + var ctr = ct.Register(stop); + + var res = moveNext(ct, tcs).Finally(ctr.Dispose); + return res; + }, + current, + dispose + ); + return self; + } + + class AnonymousAsyncEnumerator : IAsyncEnumerator + { + private readonly Func> _moveNext; + private readonly Func _current; + private readonly Action _dispose; + private bool _disposed; + + public AnonymousAsyncEnumerator(Func> moveNext, Func current, Action dispose) + { + _moveNext = moveNext; + _current = current; + _dispose = dispose; + } + + public Task MoveNext(CancellationToken cancellationToken) + { + if (_disposed) + return TaskExt.Return(false, CancellationToken.None); + + return _moveNext(cancellationToken); + } + + public T Current + { + get + { + return _current(); + } + } + + public void Dispose() + { + if (!_disposed) + { + _disposed = true; + _dispose(); + } + } + } + + public static IAsyncEnumerable Return(TValue value) + { + return new[] { value }.ToAsyncEnumerable(); + } + + public static IAsyncEnumerable Throw(Exception exception) + { + if (exception == null) + throw new ArgumentNullException("exception"); + + return Create(() => Create( + ct => TaskExt.Throw(exception, ct), + () => { throw new InvalidOperationException(); }, + () => { }) + ); + } + + public static IAsyncEnumerable Never() + { + return Create(() => Create( + (ct, tcs) => tcs.Task, + () => { throw new InvalidOperationException(); }, + () => { }) + ); + } + + public static IAsyncEnumerable Empty() + { + return Create(() => Create( + ct => TaskExt.Return(false, ct), + () => { throw new InvalidOperationException(); }, + () => { }) + ); + } + + public static IAsyncEnumerable Range(int start, int count) + { + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Enumerable.Range(start, count).ToAsyncEnumerable(); + } + + public static IAsyncEnumerable Repeat(TResult element, int count) + { + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Enumerable.Repeat(element, count).ToAsyncEnumerable(); + } + + public static IAsyncEnumerable Repeat(TResult element) + { + return Create(() => + { + return Create( + ct => TaskExt.Return(true, ct), + () => element, + () => { } + ); + }); + } + + public static IAsyncEnumerable Defer(Func> factory) + { + if (factory == null) + throw new ArgumentNullException("factory"); + + return Create(() => factory().GetEnumerator()); + } + + public static IAsyncEnumerable Generate(TState initialState, Func condition, Func iterate, Func resultSelector) + { + if (condition == null) + throw new ArgumentNullException("condition"); + if (iterate == null) + throw new ArgumentNullException("iterate"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return Create(() => + { + var i = initialState; + var started = false; + var current = default(TResult); + + return Create( + ct => + { + var b = false; + try + { + if (started) + i = iterate(i); + + b = condition(i); + + if (b) + current = resultSelector(i); + } + catch (Exception ex) + { + return TaskExt.Throw(ex, ct); + } + + if (!b) + return TaskExt.Return(false, ct); + + if (!started) + started = true; + + return TaskExt.Return(true, ct); + }, + () => current, + () => { } + ); + }); + } + + public static IAsyncEnumerable Using(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable + { + if (resourceFactory == null) + throw new ArgumentNullException("resourceFactory"); + if (enumerableFactory == null) + throw new ArgumentNullException("enumerableFactory"); + + return Create(() => + { + var resource = resourceFactory(); + var e = default(IAsyncEnumerator); + + try + { + e = enumerableFactory(resource).GetEnumerator(); + } + catch (Exception) + { + resource.Dispose(); + throw; + } + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, resource, e); + + var current = default(TSource); + + return Create( + (ct, tcs) => + { + e.MoveNext(cts.Token).ContinueWith(t => + { + t.Handle(tcs, + res => + { + if (res) + { + current = e.Current; + tcs.TrySetResult(true); + } + else + { + d.Dispose(); + tcs.TrySetResult(false); + } + }, + ex => + { + d.Dispose(); + tcs.TrySetException(ex); + } + ); + }); + + return tcs.Task; + }, + () => current, + d.Dispose + ); + }); + } + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs new file mode 100644 index 0000000..db33c61 --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs @@ -0,0 +1,381 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + public static IAsyncEnumerable Catch(this IAsyncEnumerable source, Func> handler) + where TException : Exception + { + if (source == null) + throw new ArgumentNullException("source"); + if (handler == null) + throw new ArgumentNullException("handler"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var a = new AssignableDisposable { Disposable = e }; + var d = new CompositeDisposable(cts, a); + var done = false; + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (!done) + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, + res => + { + tcs.TrySetResult(res); + }, + ex => + { + var err = default(IAsyncEnumerator); + + try + { + ex.Flatten().Handle(ex_ => + { + var exx = ex_ as TException; + if (exx != null) + { + err = handler(exx).GetEnumerator(); + return true; + } + + return false; + }); + } + catch (Exception ex2) + { + tcs.TrySetException(ex2); + return; + } + + if (err != null) + { + e = err; + a.Disposable = e; + + done = true; + f(tcs, ct); + } + } + ); + }); + } + else + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + tcs.TrySetResult(res); + }); + }); + } + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(a); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Catch(this IEnumerable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Catch_(); + } + + public static IAsyncEnumerable Catch(params IAsyncEnumerable[] sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Catch_(); + } + + public static IAsyncEnumerable Catch(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return new[] { first, second }.Catch_(); + } + + private static IAsyncEnumerable Catch_(this IEnumerable> sources) + { + return Create(() => + { + var se = sources.GetEnumerator(); + var e = default(IAsyncEnumerator); + + var cts = new CancellationTokenDisposable(); + var a = new AssignableDisposable(); + var d = new CompositeDisposable(cts, se, a); + + var error = default(Exception); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (e == null) + { + var b = false; + try + { + b = se.MoveNext(); + if (b) + e = se.Current.GetEnumerator(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (!b) + { + if (error != null) + { + tcs.TrySetException(error); + return; + } + + tcs.TrySetResult(false); + return; + } + + error = null; + + a.Disposable = e; + } + + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, + res => + { + tcs.TrySetResult(res); + }, + ex => + { + e.Dispose(); + e = null; + + error = ex; + f(tcs, ct); + } + ); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(a); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Finally(this IAsyncEnumerable source, Action finallyAction) + { + if (source == null) + throw new ArgumentNullException("source"); + if (finallyAction == null) + throw new ArgumentNullException("finallyAction"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var r = new Disposable(finallyAction); + var d = new CompositeDisposable(cts, e, r); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + tcs.TrySetResult(res); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumeratorSync(r); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable OnErrorResumeNext(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return OnErrorResumeNext_(new[] { first, second }); + } + + public static IAsyncEnumerable OnErrorResumeNext(params IAsyncEnumerable[] sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return OnErrorResumeNext_(sources); + } + + public static IAsyncEnumerable OnErrorResumeNext(this IEnumerable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return OnErrorResumeNext_(sources); + } + + private static IAsyncEnumerable OnErrorResumeNext_(IEnumerable> sources) + { + return Create(() => + { + var se = sources.GetEnumerator(); + var e = default(IAsyncEnumerator); + + var cts = new CancellationTokenDisposable(); + var a = new AssignableDisposable(); + var d = new CompositeDisposable(cts, se, a); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (e == null) + { + var b = false; + try + { + b = se.MoveNext(); + if (b) + e = se.Current.GetEnumerator(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (!b) + { + tcs.TrySetResult(false); + return; + } + + a.Disposable = e; + } + + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, + res => + { + if (res) + { + tcs.TrySetResult(true); + } + else + { + e.Dispose(); + e = null; + + f(tcs, ct); + } + }, + ex => + { + e.Dispose(); + e = null; + + f(tcs, ct); + } + ); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(a); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Retry(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return new[] { source }.Repeat().Catch(); + } + + public static IAsyncEnumerable Retry(this IAsyncEnumerable source, int retryCount) + { + if (source == null) + throw new ArgumentNullException("source"); + if (retryCount < 0) + throw new ArgumentOutOfRangeException("retryCount"); + + return new[] { source }.Repeat(retryCount).Catch(); + } + + private static IEnumerable Repeat(this IEnumerable source) + { + while (true) + foreach (var item in source) + yield return item; + } + + private static IEnumerable Repeat(this IEnumerable source, int count) + { + for (var i = 0; i < count; i++) + foreach (var item in source) + yield return item; + } + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs new file mode 100644 index 0000000..23c6c8d --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs @@ -0,0 +1,1250 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Sum(source, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static Task Sum(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Sum(source, selector, CancellationToken.None); + } + + public static void ForEach(this IAsyncEnumerable source, Action action) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + source.ForEachAsync(action).Wait(); + } + + public static Task ForEachAsync(this IAsyncEnumerable source, Action action) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + return ForEachAsync(source, action, CancellationToken.None); + } + + public static void ForEach(this IAsyncEnumerable source, Action action) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + source.ForEachAsync(action).Wait(); + } + + public static Task ForEachAsync(this IAsyncEnumerable source, Action action) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + return ForEachAsync(source, action, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Average(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Max(source, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Max(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Min(source, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Min(source, selector, CancellationToken.None); + } + + public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return SequenceEqual(first, second, comparer, CancellationToken.None); + } + + public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return SequenceEqual(first, second, CancellationToken.None); + } + + public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator, Func resultSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return Aggregate(source, seed, accumulator, resultSelector, CancellationToken.None); + } + + public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return Aggregate(source, seed, accumulator, CancellationToken.None); + } + + public static Task Aggregate(this IAsyncEnumerable source, Func accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return Aggregate(source, accumulator, CancellationToken.None); + } + + public static Task Count(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Count(source, CancellationToken.None); + } + + public static Task Count(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Count(source, predicate, CancellationToken.None); + } + + public static Task LongCount(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return LongCount(source, CancellationToken.None); + } + + public static Task LongCount(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return LongCount(source, predicate, CancellationToken.None); + } + + public static Task All(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return All(source, predicate, CancellationToken.None); + } + + public static Task Any(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Any(source, predicate, CancellationToken.None); + } + + public static Task Any(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Any(source, CancellationToken.None); + } + + public static Task Contains(this IAsyncEnumerable source, TSource value, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Contains(source, value, comparer, CancellationToken.None); + } + + public static Task Contains(this IAsyncEnumerable source, TSource value) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Contains(source, value, CancellationToken.None); + } + + public static Task First(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return First(source, CancellationToken.None); + } + + public static Task First(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return First(source, predicate, CancellationToken.None); + } + + public static Task FirstOrDefault(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return FirstOrDefault(source, CancellationToken.None); + } + + public static Task FirstOrDefault(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return FirstOrDefault(source, predicate, CancellationToken.None); + } + + public static Task Last(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Last(source, CancellationToken.None); + } + + public static Task Last(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Last(source, predicate, CancellationToken.None); + } + + public static Task LastOrDefault(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return LastOrDefault(source, CancellationToken.None); + } + + public static Task LastOrDefault(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return LastOrDefault(source, predicate, CancellationToken.None); + } + + public static Task Single(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Single(source, CancellationToken.None); + } + + public static Task Single(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Single(source, predicate, CancellationToken.None); + } + + public static Task SingleOrDefault(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return SingleOrDefault(source, CancellationToken.None); + } + + public static Task SingleOrDefault(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return SingleOrDefault(source, predicate, CancellationToken.None); + } + + public static Task ElementAt(this IAsyncEnumerable source, int index) + { + if (source == null) + throw new ArgumentNullException("source"); + + return ElementAt(source, index, CancellationToken.None); + } + + public static Task ElementAtOrDefault(this IAsyncEnumerable source, int index) + { + if (source == null) + throw new ArgumentNullException("source"); + + return ElementAtOrDefault(source, index, CancellationToken.None); + } + + public static Task ToArray(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return ToArray(source, CancellationToken.None); + } + + public static Task> ToList(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return ToList(source, CancellationToken.None); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ToDictionary(source, keySelector, elementSelector, comparer, CancellationToken.None); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + + return ToDictionary(source, keySelector, elementSelector, CancellationToken.None); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ToDictionary(source, keySelector, comparer, CancellationToken.None); + } + + public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return ToDictionary(source, keySelector, CancellationToken.None); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ToLookup(source, keySelector, elementSelector, comparer, CancellationToken.None); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + + return ToLookup(source, keySelector, elementSelector, CancellationToken.None); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ToLookup(source, keySelector, comparer, CancellationToken.None); + } + + public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return ToLookup(source, keySelector, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task Average(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Average(source, CancellationToken.None); + } + + public static Task IsEmpty(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.IsEmpty(CancellationToken.None); + } + + public static Task Min(this IAsyncEnumerable source, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Min(comparer, CancellationToken.None); + } + + public static Task> MinBy(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.MinBy(keySelector, CancellationToken.None); + } + + public static Task> MinBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.MinBy(keySelector, comparer, CancellationToken.None); + } + + public static Task Max(this IAsyncEnumerable source, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Max(comparer, CancellationToken.None); + } + + public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.MaxBy(keySelector, CancellationToken.None); + } + + public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.MaxBy(keySelector, comparer, CancellationToken.None); + } + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs new file mode 100644 index 0000000..a8069b2 --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs @@ -0,0 +1,755 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Threading; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + public static IAsyncEnumerable Concat(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return Create(() => + { + var switched = false; + var e = first.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var a = new AssignableDisposable { Disposable = e }; + var d = new CompositeDisposable(cts, a); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + tcs.TrySetResult(true); + } + else + { + if (switched) + { + tcs.TrySetResult(false); + } + else + { + switched = true; + + e = second.GetEnumerator(); + a.Disposable = e; + + f(tcs, ct); + } + } + }); + }); + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(a); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Zip(this IAsyncEnumerable first, IAsyncEnumerable second, Func selector) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => + { + var e1 = first.GetEnumerator(); + var e2 = second.GetEnumerator(); + var current = default(TResult); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e1, e2); + + return Create( + (ct, tcs) => + { + e1.MoveNext(cts.Token).Zip(e2.MoveNext(cts.Token), (f, s) => + { + var result = f && s; + if (result) + current = selector(e1.Current, e2.Current); + return result; + }).ContinueWith(t => + { + t.Handle(tcs, x => tcs.TrySetResult(x)); + }); + + return tcs.Task.UsingEnumerator(e1).UsingEnumerator(e2); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Except(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Create(() => + { + var e = first.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var mapTask = default(Task>); + var getMapTask = new Func>>(ct => + { + if (mapTask == null) + mapTask = second.ToDictionary(x => x, comparer, ct); + return mapTask; + }); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (!mapTask.Result.ContainsKey(e.Current)) + tcs.TrySetResult(true); + else + f(tcs, ct); + } + else + tcs.TrySetResult(false); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Except(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return first.Except(second, EqualityComparer.Default); + } + + public static IAsyncEnumerable Intersect(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Create(() => + { + var e = first.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var mapTask = default(Task>); + var getMapTask = new Func>>(ct => + { + if (mapTask == null) + mapTask = second.ToDictionary(x => x, comparer, ct); + return mapTask; + }); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + if (mapTask.Result.ContainsKey(e.Current)) + tcs.TrySetResult(true); + else + f(tcs, ct); + } + else + tcs.TrySetResult(false); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Intersect(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return first.Intersect(second, EqualityComparer.Default); + } + + public static IAsyncEnumerable Union(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return first.Concat(second).Distinct(comparer); + } + + public static IAsyncEnumerable Union(this IAsyncEnumerable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return first.Union(second, EqualityComparer.Default); + } + + public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer, CancellationToken cancellationToken) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + var tcs = new TaskCompletionSource(); + + var e1 = first.GetEnumerator(); + var e2 = second.GetEnumerator(); + + var run = default(Action); + run = ct => + { + e1.MoveNext(ct).Zip(e2.MoveNext(ct), (f, s) => + { + if (f ^ s) + { + tcs.TrySetResult(false); + return false; + } + + if (f && s) + { + var eq = default(bool); + try + { + eq = comparer.Equals(e1.Current, e2.Current); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return false; + } + + if (!eq) + { + tcs.TrySetResult(false); + return false; + } + else + return true; + } + else + { + tcs.TrySetResult(true); + return false; + } + }).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + run(ct); + }); + }); + }; + + run(cancellationToken); + + return tcs.Task.Finally(() => + { + e1.Dispose(); + e2.Dispose(); + }); + } + + public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second, CancellationToken cancellationToken) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return first.SequenceEqual(second, EqualityComparer.Default, cancellationToken); + } + + public static IAsyncEnumerable GroupJoin(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer comparer) + { + if (outer == null) + throw new ArgumentNullException("outer"); + if (inner == null) + throw new ArgumentNullException("inner"); + if (outerKeySelector == null) + throw new ArgumentNullException("outerKeySelector"); + if (innerKeySelector == null) + throw new ArgumentNullException("innerKeySelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Create(() => + { + var innerMap = default(Task>); + var getInnerMap = new Func>>(ct => + { + if (innerMap == null) + innerMap = inner.ToLookup(innerKeySelector, comparer, ct); + + return innerMap; + }); + + var outerE = outer.GetEnumerator(); + var current = default(TResult); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, outerE); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + getInnerMap(ct).ContinueWith(ti => + { + ti.Handle(tcs, map => + { + outerE.MoveNext(ct).ContinueWith(to => + { + to.Handle(tcs, res => + { + if (res) + { + var element = outerE.Current; + var key = default(TKey); + + try + { + key = outerKeySelector(element); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + var innerE = default(IAsyncEnumerable); + if (!map.Contains(key)) + innerE = AsyncEnumerable.Empty(); + else + innerE = map[key].ToAsyncEnumerable(); + + try + { + current = resultSelector(element, innerE); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + tcs.TrySetResult(true); + } + else + { + tcs.TrySetResult(false); + } + }); + }); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(outerE); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable GroupJoin(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector) + { + if (outer == null) + throw new ArgumentNullException("outer"); + if (inner == null) + throw new ArgumentNullException("inner"); + if (outerKeySelector == null) + throw new ArgumentNullException("outerKeySelector"); + if (innerKeySelector == null) + throw new ArgumentNullException("innerKeySelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return outer.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); + } + + public static IAsyncEnumerable Join(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer) + { + if (outer == null) + throw new ArgumentNullException("outer"); + if (inner == null) + throw new ArgumentNullException("inner"); + if (outerKeySelector == null) + throw new ArgumentNullException("outerKeySelector"); + if (innerKeySelector == null) + throw new ArgumentNullException("innerKeySelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Create(() => + { + var oe = outer.GetEnumerator(); + var ie = inner.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, oe, ie); + + var current = default(TResult); + var useOuter = true; + var outerMap = new Dictionary>(comparer); + var innerMap = new Dictionary>(comparer); + var q = new Queue(); + + var gate = new object(); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (q.Count > 0) + { + current = q.Dequeue(); + tcs.TrySetResult(true); + return; + } + + var b = useOuter; + if (ie == null && oe == null) + { + tcs.TrySetResult(false); + return; + } + else if (ie == null) + b = true; + else if (oe == null) + b = false; + useOuter = !useOuter; + + var enqueue = new Func((o, i) => + { + var result = default(TResult); + try + { + result = resultSelector(o, i); + } + catch (Exception exception) + { + tcs.TrySetException(exception); + return false; + } + + q.Enqueue(result); + return true; + }); + + if (b) + oe.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var element = oe.Current; + var key = default(TKey); + + try + { + key = outerKeySelector(element); + } + catch (Exception exception) + { + tcs.TrySetException(exception); + return; + } + + var outerList = default(List); + if (!outerMap.TryGetValue(key, out outerList)) + { + outerList = new List(); + outerMap.Add(key, outerList); + } + + outerList.Add(element); + + var innerList = default(List); + if (!innerMap.TryGetValue(key, out innerList)) + { + innerList = new List(); + innerMap.Add(key, innerList); + } + + foreach (var v in innerList) + { + if (!enqueue(element, v)) + return; + } + + f(tcs, ct); + } + else + { + oe.Dispose(); + oe = null; + f(tcs, ct); + } + }); + }); + else + ie.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var element = ie.Current; + var key = default(TKey); + + try + { + key = innerKeySelector(element); + } + catch (Exception exception) + { + tcs.TrySetException(exception); + return; + } + + var innerList = default(List); + if (!innerMap.TryGetValue(key, out innerList)) + { + innerList = new List(); + innerMap.Add(key, innerList); + } + + innerList.Add(element); + + var outerList = default(List); + if (!outerMap.TryGetValue(key, out outerList)) + { + outerList = new List(); + outerMap.Add(key, outerList); + } + + foreach (var v in outerList) + { + if (!enqueue(v, element)) + return; + } + + f(tcs, ct); + } + else + { + ie.Dispose(); + ie = null; + f(tcs, ct); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(oe).UsingEnumerator(ie); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Join(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector) + { + if (outer == null) + throw new ArgumentNullException("outer"); + if (inner == null) + throw new ArgumentNullException("inner"); + if (outerKeySelector == null) + throw new ArgumentNullException("outerKeySelector"); + if (innerKeySelector == null) + throw new ArgumentNullException("innerKeySelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return outer.Join(inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); + } + + public static IAsyncEnumerable Concat(this IEnumerable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Concat_(); + } + + public static IAsyncEnumerable Concat(params IAsyncEnumerable[] sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Concat_(); + } + + private static IAsyncEnumerable Concat_(this IEnumerable> sources) + { + return Create(() => + { + var se = sources.GetEnumerator(); + var e = default(IAsyncEnumerator); + + var cts = new CancellationTokenDisposable(); + var a = new AssignableDisposable(); + var d = new CompositeDisposable(cts, se, a); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (e == null) + { + var b = false; + try + { + b = se.MoveNext(); + if (b) + e = se.Current.GetEnumerator(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (!b) + { + tcs.TrySetResult(false); + return; + } + + a.Disposable = e; + } + + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + tcs.TrySetResult(true); + } + else + { + e.Dispose(); + e = null; + + f(tcs, ct); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(a); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, IAsyncEnumerable other) + { + if (source == null) + throw new ArgumentNullException("source"); + if (other == null) + throw new ArgumentNullException("other"); + + return source.SelectMany(_ => other); + } + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Single.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Single.cs new file mode 100644 index 0000000..bab56a2 --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerable.Single.cs @@ -0,0 +1,2466 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; + +namespace System.Linq +{ + public static partial class AsyncEnumerable + { + public static IAsyncEnumerable Select(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => + { + var e = source.GetEnumerator(); + var current = default(TResult); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + return Create( + (ct, tcs) => + { + e.MoveNext(cts.Token).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + current = selector(e.Current); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + tcs.TrySetResult(true); + } + else + { + tcs.TrySetResult(false); + } + }); + }); + + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Select(this IAsyncEnumerable source, Func selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => + { + var e = source.GetEnumerator(); + var current = default(TResult); + var index = 0; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + return Create( + (ct, tcs) => + { + e.MoveNext(cts.Token).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + current = selector(e.Current, index++); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + tcs.TrySetResult(true); + } + else + { + tcs.TrySetResult(false); + } + }); + }); + + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable AsAsyncEnumerable(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Select(x => x); + } + + public static IAsyncEnumerable Where(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var b = false; + try + { + b = predicate(e.Current); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (b) + tcs.TrySetResult(true); + else + f(tcs, ct); + } + else + tcs.TrySetResult(false); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Where(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Create(() => + { + var e = source.GetEnumerator(); + var index = 0; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var b = false; + try + { + b = predicate(e.Current, index++); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (b) + tcs.TrySetResult(true); + else + f(tcs, ct); + } + else + tcs.TrySetResult(false); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => + { + var e = source.GetEnumerator(); + var ie = default(IAsyncEnumerator); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var outer = default(Action, CancellationToken>); + var inner = default(Action, CancellationToken>); + + inner = (tcs, ct) => + { + ie.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + tcs.TrySetResult(true); + } + else + { + ie = null; + outer(tcs, ct); + } + }); + }); + }; + + outer = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + ie = selector(e.Current).GetEnumerator(); + inner(tcs, ct); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + } + } + else + tcs.TrySetResult(false); + }); + }); + }; + + return Create( + (ct, tcs) => + { + if (ie == null) + outer(tcs, cts.Token); + else + inner(tcs, cts.Token); + + return tcs.Task.UsingEnumerator(e); + }, + () => ie.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => + { + var e = source.GetEnumerator(); + var ie = default(IAsyncEnumerator); + var index = 0; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var outer = default(Action, CancellationToken>); + var inner = default(Action, CancellationToken>); + + inner = (tcs, ct) => + { + ie.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + tcs.TrySetResult(true); + } + else + { + ie = null; + outer(tcs, ct); + } + }); + }); + }; + + outer = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + ie = selector(e.Current, index++).GetEnumerator(); + inner(tcs, ct); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + } + } + else + tcs.TrySetResult(false); + }); + }); + }; + + return Create( + (ct, tcs) => + { + if (ie == null) + outer(tcs, cts.Token); + else + inner(tcs, cts.Token); + + return tcs.Task.UsingEnumerator(e); + }, + () => ie.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector, Func resultSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return source.SelectMany(x => selector(x).Select(y => resultSelector(x, y))); + } + + public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector, Func resultSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return source.SelectMany((x, i) => selector(x, i).Select(y => resultSelector(x, y))); + } + + public static IAsyncEnumerable OfType(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Where(x => x is TType).Cast(); + } + + public static IAsyncEnumerable Cast(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Select(x => (TResult)x); + } + + public static IAsyncEnumerable Take(this IAsyncEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Create(() => + { + var e = source.GetEnumerator(); + var n = count; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + return Create( + (ct, tcs) => + { + if (n == 0) + return TaskExt.Return(false, cts.Token); + + e.MoveNext(cts.Token).ContinueWith(t => + { + t.Handle(tcs, res => + { + --n; + tcs.TrySetResult(res); + }); + }); + + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable TakeWhile(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + return Create( + (ct, tcs) => + { + e.MoveNext(cts.Token).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var b = false; + + try + { + b = predicate(e.Current); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (b) + { + tcs.TrySetResult(true); + return; + } + } + tcs.TrySetResult(false); + }); + }); + + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable TakeWhile(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Create(() => + { + var e = source.GetEnumerator(); + var index = 0; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + return Create( + (ct, tcs) => + { + e.MoveNext(cts.Token).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var b = false; + + try + { + b = predicate(e.Current, index++); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (b) + { + tcs.TrySetResult(true); + return; + } + } + tcs.TrySetResult(false); + }); + }); + + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Skip(this IAsyncEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Create(() => + { + var e = source.GetEnumerator(); + var n = count; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (n == 0) + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, x => tcs.TrySetResult(x)); + }); + else + { + --n; + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (!res) + tcs.TrySetResult(false); + else + f(tcs, ct); + }); + }); + } + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SkipWhile(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Create(() => + { + var e = source.GetEnumerator(); + var skipping = true; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (skipping) + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var result = false; + try + { + result = predicate(e.Current); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + if (result) + f(tcs, ct); + else + { + skipping = false; + tcs.TrySetResult(true); + } + } + else + tcs.TrySetResult(false); + }); + }); + else + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, x => tcs.TrySetResult(x)); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SkipWhile(this IAsyncEnumerable source, Func predicate) + { + if (source == null) + throw new ArgumentNullException("source"); + if (predicate == null) + throw new ArgumentNullException("predicate"); + + return Create(() => + { + var e = source.GetEnumerator(); + var skipping = true; + var index = 0; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (skipping) + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var result = false; + try + { + result = predicate(e.Current, index++); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + if (result) + f(tcs, ct); + else + { + skipping = false; + tcs.TrySetResult(true); + } + } + else + tcs.TrySetResult(false); + }); + }); + else + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, x => tcs.TrySetResult(x)); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => e.Current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable DefaultIfEmpty(this IAsyncEnumerable source, TSource defaultValue) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Create(() => + { + var done = false; + var hasElements = false; + var e = source.GetEnumerator(); + var current = default(TSource); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (done) + tcs.TrySetResult(false); + else + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + hasElements = true; + current = e.Current; + tcs.TrySetResult(true); + } + else + { + done = true; + + if (!hasElements) + { + current = defaultValue; + tcs.TrySetResult(true); + } + else + tcs.TrySetResult(false); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable DefaultIfEmpty(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.DefaultIfEmpty(default(TSource)); + } + + public static IAsyncEnumerable Distinct(this IAsyncEnumerable source, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Defer(() => + { + var set = new HashSet(comparer); + return source.Where(set.Add); + }); + } + + public static IAsyncEnumerable Distinct(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Distinct(EqualityComparer.Default); + } + + public static IAsyncEnumerable Reverse(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Create(() => + { + var e = source.GetEnumerator(); + var stack = default(Stack); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + return Create( + (ct, tcs) => + { + if (stack == null) + { + Create(() => e).Aggregate(new Stack(), (s, x) => { s.Push(x); return s; }, cts.Token).ContinueWith(t => + { + t.Handle(tcs, res => + { + stack = res; + tcs.TrySetResult(stack.Count > 0); + }); + }, cts.Token); + } + else + { + stack.Pop(); + tcs.TrySetResult(stack.Count > 0); + } + + return tcs.Task.UsingEnumerator(e); + }, + () => stack.Peek(), + d.Dispose + ); + }); + } + + public static IOrderedAsyncEnumerable OrderBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return new OrderedAsyncEnumerable( + Create(() => + { + var current = default(IEnumerable); + + return Create( + ct => + { + var tcs = new TaskCompletionSource(); + if (current == null) + { + source.ToList(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + current = res; + tcs.TrySetResult(true); + }); + }); + } + else + tcs.TrySetResult(false); + return tcs.Task; + }, + () => current, + () => { } + ); + }), + keySelector, + comparer + ); + } + + public static IOrderedAsyncEnumerable OrderBy(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.OrderBy(keySelector, Comparer.Default); + } + + public static IOrderedAsyncEnumerable OrderByDescending(this IAsyncEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.OrderBy(keySelector, new ReverseComparer(comparer)); + } + + public static IOrderedAsyncEnumerable OrderByDescending(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.OrderByDescending(keySelector, Comparer.Default); + } + + public static IOrderedAsyncEnumerable ThenBy(this IOrderedAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.ThenBy(keySelector, Comparer.Default); + } + + public static IOrderedAsyncEnumerable ThenBy(this IOrderedAsyncEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.CreateOrderedEnumerable(keySelector, comparer, false); + } + + public static IOrderedAsyncEnumerable ThenByDescending(this IOrderedAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.ThenByDescending(keySelector, Comparer.Default); + } + + public static IOrderedAsyncEnumerable ThenByDescending(this IOrderedAsyncEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.CreateOrderedEnumerable(keySelector, comparer, true); + } + + static IEnumerable> GroupUntil(this IEnumerable source, Func keySelector, Func elementSelector, IComparer comparer) + { + var group = default(EnumerableGrouping); + foreach (var x in source) + { + var key = keySelector(x); + if (group == null || comparer.Compare(group.Key, key) != 0) + { + group = new EnumerableGrouping(key); + yield return group; + } + group.Add(elementSelector(x)); + } + } + + class OrderedAsyncEnumerable : IOrderedAsyncEnumerable + { + private readonly IAsyncEnumerable> equivalenceClasses; + private readonly Func keySelector; + private readonly IComparer comparer; + + public OrderedAsyncEnumerable(IAsyncEnumerable> equivalenceClasses, Func keySelector, IComparer comparer) + { + this.equivalenceClasses = equivalenceClasses; + this.keySelector = keySelector; + this.comparer = comparer; + } + + public IOrderedAsyncEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending) + { + if (descending) + comparer = new ReverseComparer(comparer); + + return new OrderedAsyncEnumerable(Classes(), keySelector, comparer); + } + + IAsyncEnumerable> Classes() + { + return Create(() => + { + var e = equivalenceClasses.GetEnumerator(); + var list = new List>(); + var e1 = default(IEnumerator>); + + var cts = new CancellationTokenDisposable(); + var d1 = new AssignableDisposable(); + var d = new CompositeDisposable(cts, e, d1); + + var f = default(Action, CancellationToken>); + var g = default(Action, CancellationToken>); + + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + foreach (var group in e.Current.OrderBy(keySelector, comparer).GroupUntil(keySelector, x => x, comparer)) + list.Add(group); + f(tcs, ct); + } + catch (Exception exception) + { + tcs.TrySetException(exception); + return; + } + } + else + { + e.Dispose(); + + e1 = list.GetEnumerator(); + d1.Disposable = e1; + + g(tcs, ct); + } + }); + }); + }; + + g = (tcs, ct) => + { + var res = false; + try + { + res = e1.MoveNext(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + tcs.TrySetResult(res); + }; + + return Create( + (ct, tcs) => + { + if (e1 != null) + { + g(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e1); + } + else + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + } + }, + () => e1.Current, + d.Dispose + ); + }); + } + + public IAsyncEnumerator GetEnumerator() + { + return Classes().SelectMany(x => x.ToAsyncEnumerable()).GetEnumerator(); + } + } + + class ReverseComparer : IComparer + { + IComparer comparer; + + public ReverseComparer(IComparer comparer) + { + this.comparer = comparer; + } + + public int Compare(T x, T y) + { + return -comparer.Compare(x, y); + } + } + + public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Create(() => + { + var gate = new object(); + + var e = source.GetEnumerator(); + var count = 1; + + var map = new Dictionary>(comparer); + var list = new List>(); + + var index = 0; + + var current = default(IAsyncGrouping); + var faulted = default(Exception); + + var task = default(Task); + + var cts = new CancellationTokenDisposable(); + var refCount = new Disposable( + () => + { + if (Interlocked.Decrement(ref count) == 0) + e.Dispose(); + } + ); + var d = new CompositeDisposable(cts, refCount); + + var iterateSource = default(Func>); + iterateSource = ct => + { + var tcs = default(TaskCompletionSource); + lock (gate) + { + if (task != null) + { + return task; + } + else + { + tcs = new TaskCompletionSource(); + task = tcs.Task.UsingEnumerator(e); + } + } + + if (faulted != null) + { + tcs.TrySetException(faulted); + return task; + } + + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, + res => + { + if (res) + { + var key = default(TKey); + var element = default(TElement); + + var cur = e.Current; + try + { + key = keySelector(cur); + element = elementSelector(cur); + } + catch (Exception exception) + { + foreach (var v in map.Values) + v.Error(exception); + + tcs.TrySetException(exception); + return; + } + + var group = default(Grouping); + if (!map.TryGetValue(key, out group)) + { + group = new Grouping(key, iterateSource, refCount); + map.Add(key, group); + lock (list) + list.Add(group); + + Interlocked.Increment(ref count); + } + group.Add(element); + } + + tcs.TrySetResult(res); + }, + ex => + { + foreach (var v in map.Values) + v.Error(ex); + + faulted = ex; + tcs.TrySetException(ex); + } + ); + + lock (gate) + { + task = null; + } + }); + + return tcs.Task.UsingEnumerator(e); + }; + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + iterateSource(ct).ContinueWith(t => + { + t.Handle(tcs, + res => + { + current = null; + lock (list) + { + if (index < list.Count) + current = list[index++]; + } + + if (current != null) + { + tcs.TrySetResult(true); + } + else + { + if (res) + f(tcs, ct); + else + tcs.TrySetResult(false); + } + } + ); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task; + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + + return source.GroupBy(keySelector, elementSelector, EqualityComparer.Default); + } + + public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.GroupBy(keySelector, x => x, comparer); + } + + public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.GroupBy(keySelector, x => x, EqualityComparer.Default); + } + + public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.GroupBy(keySelector, elementSelector, comparer).Select(g => resultSelector(g.Key, g)); + } + + public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (elementSelector == null) + throw new ArgumentNullException("elementSelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return source.GroupBy(keySelector, elementSelector, EqualityComparer.Default).Select(g => resultSelector(g.Key, g)); + } + + public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.GroupBy(keySelector, x => x, comparer).Select(g => resultSelector(g.Key, g)); + } + + public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return source.GroupBy(keySelector, x => x, EqualityComparer.Default).Select(g => resultSelector(g.Key, g)); + } + + class Grouping : IAsyncGrouping + { + private readonly Func> iterateSource; + private readonly IDisposable sourceDisposable; + private readonly List elements = new List(); + private bool done = false; + private Exception exception = null; + + public Grouping(TKey key, Func> iterateSource, IDisposable sourceDisposable) + { + this.iterateSource = iterateSource; + this.sourceDisposable = sourceDisposable; + Key = key; + } + + public TKey Key + { + get; + private set; + } + + public void Add(TElement element) + { + lock (elements) + elements.Add(element); + } + + public void Error(Exception exception) + { + done = true; + this.exception = exception; + } + + public IAsyncEnumerator GetEnumerator() + { + var index = -1; + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, sourceDisposable); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + var size = 0; + lock (elements) + size = elements.Count; + + if (index < size) + { + tcs.TrySetResult(true); + } + else if (done) + { + if (exception != null) + tcs.TrySetException(exception); + else + tcs.TrySetResult(false); + } + else + { + iterateSource(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + f(tcs, ct); + else + tcs.TrySetResult(false); + }); + }); + } + }; + + return Create( + (ct, tcs) => + { + ++index; + f(tcs, cts.Token); + return tcs.Task; + }, + () => elements[index], + d.Dispose + ); + } + } + + #region Ix + + public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + + return DoHelper(source, onNext, _ => { }, () => { }); + } + + public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext, Action onCompleted) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onCompleted == null) + throw new ArgumentNullException("onCompleted"); + + return DoHelper(source, onNext, _ => { }, onCompleted); + } + + public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext, Action onError) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onError == null) + throw new ArgumentNullException("onError"); + + return DoHelper(source, onNext, onError, () => { }); + } + + public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext, Action onError, Action onCompleted) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onError == null) + throw new ArgumentNullException("onError"); + if (onCompleted == null) + throw new ArgumentNullException("onCompleted"); + + return DoHelper(source, onNext, onError, onCompleted); + } + +#if !NO_RXINTERFACES + public static IAsyncEnumerable Do(this IAsyncEnumerable source, IObserver observer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (observer == null) + throw new ArgumentNullException("observer"); + + return DoHelper(source, observer.OnNext, observer.OnError, observer.OnCompleted); + } +#endif + + private static IAsyncEnumerable DoHelper(this IAsyncEnumerable source, Action onNext, Action onError, Action onCompleted) + { + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var current = default(TSource); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + if (!t.IsCanceled) + { + try + { + if (t.IsFaulted) + { + onError(t.Exception); + } + else if (!t.Result) + { + onCompleted(); + } + else + { + current = e.Current; + onNext(current); + } + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + } + + t.Handle(tcs, res => + { + tcs.TrySetResult(res); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static void ForEach(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + source.ForEachAsync(action, cancellationToken).Wait(cancellationToken); + } + + public static Task ForEachAsync(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + return source.ForEachAsync((x, i) => action(x), cancellationToken); + } + + public static void ForEach(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + source.ForEachAsync(action, cancellationToken).Wait(cancellationToken); + } + + public static Task ForEachAsync(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) + { + if (source == null) + throw new ArgumentNullException("source"); + if (action == null) + throw new ArgumentNullException("action"); + + var tcs = new TaskCompletionSource(); + + var e = source.GetEnumerator(); + + var i = 0; + + var f = default(Action); + f = ct => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + try + { + action(e.Current, i++); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + f(ct); + } + else + tcs.TrySetResult(true); + }); + }); + }; + + f(cancellationToken); + + return tcs.Task.UsingEnumerator(e); + } + + public static IAsyncEnumerable Repeat(this IAsyncEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Create(() => + { + var e = default(IAsyncEnumerator); + var a = new AssignableDisposable(); + var n = count; + var current = default(TSource); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, a); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (e == null) + { + if (n-- == 0) + { + tcs.TrySetResult(false); + return; + } + + try + { + e = source.GetEnumerator(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + a.Disposable = e; + } + + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + current = e.Current; + tcs.TrySetResult(true); + } + else + { + e = null; + f(tcs, ct); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(d); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Repeat(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Create(() => + { + var e = default(IAsyncEnumerator); + var a = new AssignableDisposable(); + var current = default(TSource); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, a); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (e == null) + { + try + { + e = source.GetEnumerator(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + a.Disposable = e; + } + + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + current = e.Current; + tcs.TrySetResult(true); + } + else + { + e = null; + f(tcs, ct); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(d); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable IgnoreElements(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (!res) + { + tcs.TrySetResult(false); + return; + } + + f(tcs, ct); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => { throw new InvalidOperationException(); }, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable StartWith(this IAsyncEnumerable source, params TSource[] values) + { + if (source == null) + throw new ArgumentNullException("source"); + + return values.ToAsyncEnumerable().Concat(source); + } + + public static IAsyncEnumerable> Buffer(this IAsyncEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count <= 0) + throw new ArgumentOutOfRangeException("count"); + + return source.Buffer_(count, count); + } + + public static IAsyncEnumerable> Buffer(this IAsyncEnumerable source, int count, int skip) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count <= 0) + throw new ArgumentOutOfRangeException("count"); + if (skip <= 0) + throw new ArgumentOutOfRangeException("skip"); + + return source.Buffer_(count, skip); + } + + private static IAsyncEnumerable> Buffer_(this IAsyncEnumerable source, int count, int skip) + { + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var buffers = new Queue>(); + + var i = 0; + + var current = default(IList); + var stopped = false; + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (!stopped) + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var item = e.Current; + + if (i++ % skip == 0) + buffers.Enqueue(new List(count)); + + foreach (var buffer in buffers) + buffer.Add(item); + + if (buffers.Count > 0 && buffers.Peek().Count == count) + { + current = buffers.Dequeue(); + tcs.TrySetResult(true); + return; + } + + f(tcs, ct); + } + else + { + stopped = true; + e.Dispose(); + + f(tcs, ct); + } + }); + }); + } + else + { + if (buffers.Count > 0) + { + current = buffers.Dequeue(); + tcs.TrySetResult(true); + } + else + { + tcs.TrySetResult(false); + } + } + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Distinct(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return Defer(() => + { + var set = new HashSet(comparer); + return source.Where(item => set.Add(keySelector(item))); + }); + } + + public static IAsyncEnumerable Distinct(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.Distinct(keySelector, EqualityComparer.Default); + } + + public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.DistinctUntilChanged_(x => x, EqualityComparer.Default); + } + + public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.DistinctUntilChanged_(x => x, comparer); + } + + public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.DistinctUntilChanged_(keySelector, EqualityComparer.Default); + } + + public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.DistinctUntilChanged_(keySelector, comparer); + } + + private static IAsyncEnumerable DistinctUntilChanged_(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + { + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var currentKey = default(TKey); + var hasCurrentKey = false; + var current = default(TSource); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var item = e.Current; + var key = default(TKey); + var comparerEquals = false; + + try + { + key = keySelector(item); + + if (hasCurrentKey) + { + comparerEquals = comparer.Equals(currentKey, key); + } + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + if (!hasCurrentKey || !comparerEquals) + { + hasCurrentKey = true; + currentKey = key; + + current = item; + tcs.TrySetResult(true); + } + else + { + f(tcs, ct); + } + } + else + { + tcs.TrySetResult(false); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Expand(this IAsyncEnumerable source, Func> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => + { + var e = default(IAsyncEnumerator); + + var cts = new CancellationTokenDisposable(); + var a = new AssignableDisposable(); + var d = new CompositeDisposable(cts, a); + + var queue = new Queue>(); + queue.Enqueue(source); + + var current = default(TSource); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (e == null) + { + if (queue.Count > 0) + { + var src = queue.Dequeue(); + + try + { + e = src.GetEnumerator(); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + a.Disposable = e; + f(tcs, ct); + } + else + { + tcs.TrySetResult(false); + } + } + else + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var item = e.Current; + + var next = default(IAsyncEnumerable); + try + { + next = selector(item); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + queue.Enqueue(next); + current = item; + tcs.TrySetResult(true); + } + else + { + e = null; + f(tcs, ct); + } + }); + }); + } + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(a); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Scan(this IAsyncEnumerable source, TAccumulate seed, Func accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var acc = seed; + var current = default(TAccumulate); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (!res) + { + tcs.TrySetResult(false); + return; + } + + var item = e.Current; + try + { + acc = accumulator(acc, item); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + current = acc; + tcs.TrySetResult(true); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable Scan(this IAsyncEnumerable source, Func accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var hasSeed = false; + var acc = default(TSource); + var current = default(TSource); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (!res) + { + tcs.TrySetResult(false); + return; + } + + var item = e.Current; + + if (!hasSeed) + { + hasSeed = true; + acc = item; + f(tcs, ct); + return; + } + + try + { + acc = accumulator(acc, item); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + current = acc; + tcs.TrySetResult(true); + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable TakeLast(this IAsyncEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var q = new Queue(count); + var done = false; + var current = default(TSource); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + if (!done) + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var item = e.Current; + + if (q.Count >= count) + q.Dequeue(); + q.Enqueue(item); + } + else + { + done = true; + e.Dispose(); + } + + f(tcs, ct); + }); + }); + } + else + { + if (q.Count > 0) + { + current = q.Dequeue(); + tcs.TrySetResult(true); + } + else + { + tcs.TrySetResult(false); + } + } + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + public static IAsyncEnumerable SkipLast(this IAsyncEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Create(() => + { + var e = source.GetEnumerator(); + + var cts = new CancellationTokenDisposable(); + var d = new CompositeDisposable(cts, e); + + var q = new Queue(); + var current = default(TSource); + + var f = default(Action, CancellationToken>); + f = (tcs, ct) => + { + e.MoveNext(ct).ContinueWith(t => + { + t.Handle(tcs, res => + { + if (res) + { + var item = e.Current; + + q.Enqueue(item); + if (q.Count > count) + { + current = q.Dequeue(); + tcs.TrySetResult(true); + } + else + { + f(tcs, ct); + } + } + else + { + tcs.TrySetResult(false); + } + }); + }); + }; + + return Create( + (ct, tcs) => + { + f(tcs, cts.Token); + return tcs.Task.UsingEnumerator(e); + }, + () => current, + d.Dispose + ); + }); + } + + #endregion + } +} diff --git a/Ix/System.Interactive.Async/AsyncEnumerator.cs b/Ix/System.Interactive.Async/AsyncEnumerator.cs new file mode 100644 index 0000000..003141f --- /dev/null +++ b/Ix/System.Interactive.Async/AsyncEnumerator.cs @@ -0,0 +1,26 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Linq; +using System.Threading.Tasks; +using System.Threading; + +namespace System.Collections.Generic +{ + public static class AsyncEnumerator + { + /// + /// Advances the enumerator to the next element in the sequence, returning the result asynchronously. + /// + /// + /// Task containing the result of the operation: true if the enumerator was successfully advanced + /// to the next element; false if the enumerator has passed the end of the sequence. + /// + public static Task MoveNext(this IAsyncEnumerator enumerator) + { + if (enumerator == null) + throw new ArgumentNullException("enumerator"); + + return enumerator.MoveNext(CancellationToken.None); + } + } +} diff --git a/Ix/System.Interactive.Async/Disposables.cs b/Ix/System.Interactive.Async/Disposables.cs new file mode 100644 index 0000000..05d5554 --- /dev/null +++ b/Ix/System.Interactive.Async/Disposables.cs @@ -0,0 +1,89 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Threading; + +namespace System.Linq +{ + class CancellationTokenDisposable : IDisposable + { + private CancellationTokenSource cts = new CancellationTokenSource(); + + public CancellationToken Token { get { return cts.Token; } } + + public void Dispose() + { + if (!cts.IsCancellationRequested) + cts.Cancel(); + } + } + + class CompositeDisposable : IDisposable + { + private readonly IDisposable[] _dispose; + + public CompositeDisposable(params IDisposable[] dispose) + { + _dispose = dispose; + } + + public void Dispose() + { + foreach (var d in _dispose) + d.Dispose(); + } + } + + class AssignableDisposable : IDisposable + { + private object _gate = new object(); + private IDisposable _disposable; + private bool _disposed; + + public IDisposable Disposable + { + set + { + lock (_gate) + { + if (_disposable != null) + _disposable.Dispose(); + + _disposable = value; + + if (_disposed) + _disposable.Dispose(); + } + } + } + + public void Dispose() + { + lock (_gate) + { + if (!_disposed) + { + _disposed = true; + + if (_disposable != null) + _disposable.Dispose(); + } + } + } + } + + class Disposable : IDisposable + { + private readonly Action _dispose; + + public Disposable(Action dispose) + { + _dispose = dispose; + } + + public void Dispose() + { + _dispose(); + } + } +} diff --git a/Ix/System.Interactive.Async/EnumerableGrouping.cs b/Ix/System.Interactive.Async/EnumerableGrouping.cs new file mode 100644 index 0000000..69469c8 --- /dev/null +++ b/Ix/System.Interactive.Async/EnumerableGrouping.cs @@ -0,0 +1,34 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; + +namespace System.Linq +{ + class EnumerableGrouping : IGrouping + { + List elements = new List(); + + public EnumerableGrouping(TKey key) + { + Key = key; + } + + public void Add(TElement element) + { + elements.Add(element); + } + + public TKey Key { get; private set; } + + public IEnumerator GetEnumerator() + { + return elements.GetEnumerator(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return this.GetEnumerator(); + } + } +} diff --git a/Ix/System.Interactive.Async/IAsyncEnumerable.cs b/Ix/System.Interactive.Async/IAsyncEnumerable.cs new file mode 100644 index 0000000..8d892e1 --- /dev/null +++ b/Ix/System.Interactive.Async/IAsyncEnumerable.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; + +namespace System.Collections.Generic +{ + /// + /// Asynchronous version of the IEnumerable<T> interface, allowing elements of the + /// enumerable sequence to be retrieved asynchronously. + /// + /// Element type. + public interface IAsyncEnumerable< +#if DESKTOPCLR40 || SILVERLIGHT4 + out +#endif + T> + { + /// + /// Gets an asynchronous enumerator over the sequence. + /// + /// Enumerator for asynchronous enumeration over the sequence. + IAsyncEnumerator GetEnumerator(); + } +} diff --git a/Ix/System.Interactive.Async/IAsyncEnumerator.cs b/Ix/System.Interactive.Async/IAsyncEnumerator.cs new file mode 100644 index 0000000..72cfdbc --- /dev/null +++ b/Ix/System.Interactive.Async/IAsyncEnumerator.cs @@ -0,0 +1,34 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Threading.Tasks; +using System.Threading; + +namespace System.Collections.Generic +{ + /// + /// Asynchronous version of the IEnumerator<T> interface, allowing elements to be + /// retrieved asynchronously. + /// + /// Element type. + public interface IAsyncEnumerator< +#if DESKTOPCLR40 || SILVERLIGHT4 + out +#endif + T> : IDisposable + { + /// + /// Advances the enumerator to the next element in the sequence, returning the result asynchronously. + /// + /// Cancellation token that can be used to cancel the operation. + /// + /// Task containing the result of the operation: true if the enumerator was successfully advanced + /// to the next element; false if the enumerator has passed the end of the sequence. + /// + Task MoveNext(CancellationToken cancellationToken); + + /// + /// Gets the current element in the iteration. + /// + T Current { get; } + } +} diff --git a/Ix/System.Interactive.Async/IAsyncGrouping.cs b/Ix/System.Interactive.Async/IAsyncGrouping.cs new file mode 100644 index 0000000..61abc60 --- /dev/null +++ b/Ix/System.Interactive.Async/IAsyncGrouping.cs @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; + +namespace System.Linq +{ + public interface IAsyncGrouping< +#if DESKTOPCLR4 || SILVERLIGHT4 + out +#endif + TKey, +#if DESKTOPCLR4 || SILVERLIGHT4 + out +#endif + TElement> : IAsyncEnumerable + { + TKey Key { get; } + } +} diff --git a/Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs b/Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs new file mode 100644 index 0000000..a1e430d --- /dev/null +++ b/Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs @@ -0,0 +1,15 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; + +namespace System.Linq +{ + public interface IOrderedAsyncEnumerable< +#if DESKTOPCLR4 || SILVERLIGHT4 + out +#endif + TElement> : IAsyncEnumerable + { + IOrderedAsyncEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending); + } +} diff --git a/Ix/System.Interactive.Async/Properties/AssemblyInfo.cs b/Ix/System.Interactive.Async/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..b887de0 --- /dev/null +++ b/Ix/System.Interactive.Async/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +using System; +using System.Reflection; +using System.Resources; +using System.Runtime.InteropServices; +using System.Security; + +[assembly: AssemblyTitle("System.Interactive.Async")] +// Notice: same description as in the .nuspec files; see Source/Interactive Extensions/Setup/NuGet +[assembly: AssemblyDescription("Interactive Extensions Async Library used to express queries over asynchronous enumerable sequences.")] +#if DEBUG +[assembly: AssemblyConfiguration("Debug")] +#else +[assembly: AssemblyConfiguration("Retail")] +#endif +[assembly: AssemblyCompany("Microsoft Corporation")] +#if STABLE +[assembly: AssemblyProduct("Interactive Extensions")] +#else +[assembly: AssemblyProduct("Interactive Extensions (Experimental Release)")] +#endif +[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")] +[assembly: NeutralResourcesLanguage("en-US")] + +#if !PLIB +[assembly: ComVisible(false)] +#endif + +[assembly: CLSCompliant(true)] + +#if DESKTOPCLR && NO_CODECOVERAGE +[assembly: AllowPartiallyTrustedCallers] +#endif + +// +// Note: Assembly (file) version numbers get inserted by the build system on the fly. Inspect the Team Build workflows +// and the custom activity in Build/Source/Activities/AppendVersionInfo.cs for more information. +// diff --git a/Ix/System.Interactive.Async/System.Interactive.Async.csproj b/Ix/System.Interactive.Async/System.Interactive.Async.csproj new file mode 100644 index 0000000..b8143b2 --- /dev/null +++ b/Ix/System.Interactive.Async/System.Interactive.Async.csproj @@ -0,0 +1,47 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {7269A578-326A-4C3E-9874-A2D2600095BC} + Library + Properties + System.Interactive.Async + System.Interactive.Async + v4.0 + 512 + + + + $(OutputPath)\$(AssemblyName).XML + + + Profile1 + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Ix/System.Interactive.Async/TaskExt.cs b/Ix/System.Interactive.Async/TaskExt.cs new file mode 100644 index 0000000..5f714ad --- /dev/null +++ b/Ix/System.Interactive.Async/TaskExt.cs @@ -0,0 +1,134 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; + +namespace System.Threading.Tasks +{ + static class TaskExt + { + public static Task Return(T value, CancellationToken cancellationToken) + { + var tcs = new TaskCompletionSource(); + tcs.TrySetResult(value); + return tcs.Task; + } + + public static Task Throw(Exception exception, CancellationToken cancellationToken) + { + var tcs = new TaskCompletionSource(); + tcs.TrySetException(exception); + return tcs.Task; + } + + public static void Handle(this Task task, TaskCompletionSource tcs, Action success) + { + Handle(task, tcs, success, ex => tcs.TrySetException(ex), () => tcs.TrySetCanceled()); + } + + public static void Handle(this Task task, TaskCompletionSource tcs, Action success, Action error) + { + Handle(task, tcs, success, error, () => tcs.TrySetCanceled()); + } + + public static void Handle(this Task task, TaskCompletionSource tcs, Action success, Action error, Action canceled) + { + if (task.IsFaulted) + error(task.Exception); + else if (task.IsCanceled) + canceled(); + else if (task.IsCompleted) + success(task.Result); + } + + public static Task UsingEnumerator(this Task task, IDisposable disposable) + { + task.ContinueWith(t => + { + if (t.IsFaulted) + { + var ignored = t.Exception; // don't remove! + } + + if (t.IsFaulted || t.IsCanceled || !t.Result) + disposable.Dispose(); + }, TaskContinuationOptions.ExecuteSynchronously); + + return task; + } + + public static Task UsingEnumeratorSync(this Task task, IDisposable disposable) + { + var tcs = new TaskCompletionSource(); + + task.ContinueWith(t => + { + if (t.IsFaulted || t.IsCanceled || !t.Result) + disposable.Dispose(); // TODO: Check whether we need exception handling here! + + t.Handle(tcs, res => tcs.TrySetResult(res)); + }, TaskContinuationOptions.ExecuteSynchronously); + + return tcs.Task; + } + + public static Task Finally(this Task task, Action action) + { + task.ContinueWith(t => + { + if (t.IsFaulted) + { + var ignored = t.Exception; // don't remove! + } + + action(); + }, TaskContinuationOptions.ExecuteSynchronously); + + return task; + } + + public static Task Zip(this Task t1, Task t2, Func f) + { + var gate = new object(); + var tcs = new TaskCompletionSource(); + + var i = 2; + var complete = new Action(t => + { + if (Interlocked.Decrement(ref i) == 0) + { + var exs = new List(); + if (t1.IsFaulted) + exs.Add(t1.Exception); + if (t2.IsFaulted) + exs.Add(t2.Exception); + + if (exs.Count > 0) + tcs.TrySetException(exs); + else if (t1.IsCanceled || t2.IsCanceled) + tcs.TrySetCanceled(); + else + { + var res = default(V); + try + { + res = f(t1.Result, t2.Result); + } + catch (Exception ex) + { + tcs.TrySetException(ex); + return; + } + + tcs.TrySetResult(res); + } + } + }); + + t1.ContinueWith(complete); + t2.ContinueWith(complete); + + return tcs.Task; + } + } +} diff --git a/Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs b/Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..03b49a8 --- /dev/null +++ b/Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +using System; +using System.Reflection; +using System.Resources; +using System.Runtime.InteropServices; +using System.Security; + +[assembly: AssemblyTitle("System.Interactive.Providers")] +// Notice: same description as in the .nuspec files; see Source/Interactive Extensions/Setup/NuGet +[assembly: AssemblyDescription("Interactive Extensions Providers Library used to build query providers and express queries over enumerable sequences.")] +#if DEBUG +[assembly: AssemblyConfiguration("Debug")] +#else +[assembly: AssemblyConfiguration("Retail")] +#endif +[assembly: AssemblyCompany("Microsoft Corporation")] +#if STABLE +[assembly: AssemblyProduct("Interactive Extensions")] +#else +[assembly: AssemblyProduct("Interactive Extensions (Experimental Release)")] +#endif +[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")] +[assembly: NeutralResourcesLanguage("en-US")] + +#if !PLIB +[assembly: ComVisible(false)] +#endif + +[assembly: CLSCompliant(true)] + +#if DESKTOPCLR && NO_CODECOVERAGE +[assembly: AllowPartiallyTrustedCallers] +#endif + +// +// Note: Assembly (file) version numbers get inserted by the build system on the fly. Inspect the Team Build workflows +// and the custom activity in Build/Source/Activities/AppendVersionInfo.cs for more information. +// diff --git a/Ix/System.Interactive.Providers/QueryableEx.cs b/Ix/System.Interactive.Providers/QueryableEx.cs new file mode 100644 index 0000000..20f7ec8 --- /dev/null +++ b/Ix/System.Interactive.Providers/QueryableEx.cs @@ -0,0 +1,2327 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System.Collections.Generic; +using System.ComponentModel; +using System.Globalization; +using System.Linq.Expressions; +using System.Reflection; + +namespace System.Linq +{ + /// + /// Provides a set of additional static methods that allow querying enumerable sequences. + /// + public static class QueryableEx + { + /// + /// Determines whether an enumerable sequence is empty. + /// + /// Source sequence element type. + /// Source sequence. + /// true if the sequence is empty; false otherwise. + public static bool IsEmpty(this IQueryable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.Execute( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static bool IsEmpty(IEnumerable source) + { + return EnumerableEx.IsEmpty(source); + } +#pragma warning restore 1591 + + /// + /// Returns the minimum value in the enumerable sequence by using the specified comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Comparer used to determine the minimum value. + /// Minimum value in the sequence. + public static TSource Min(this IQueryable source, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.Execute( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(comparer, typeof(IComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static TSource Min(IEnumerable source, IComparer comparer) + { + return EnumerableEx.Min(source, comparer); + } +#pragma warning restore 1591 + + /// + /// Returns the elements with the minimum key value by using the default comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// List with the elements that share the same minimum key value. + public static IList MinBy(this IQueryable source, Expression> keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.Provider.Execute>( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IList MinBy(IEnumerable source, Func keySelector) + { + return EnumerableEx.MinBy(source, keySelector); + } +#pragma warning restore 1591 + + /// + /// Returns the elements with the minimum key value by using the specified comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// Comparer used to determine the minimum key value. + /// List with the elements that share the same minimum key value. + public static IList MinBy(this IQueryable source, Expression> keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.Execute>( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector, + Expression.Constant(comparer, typeof(IComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IList MinBy(IEnumerable source, Func keySelector, IComparer comparer) + { + return EnumerableEx.MinBy(source, keySelector, comparer); + } +#pragma warning restore 1591 + + /// + /// Returns the maximum value in the enumerable sequence by using the specified comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Comparer used to determine the maximum value. + /// Maximum value in the sequence. + public static TSource Max(this IQueryable source, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.Execute( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(comparer, typeof(IComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static TSource Max(IEnumerable source, IComparer comparer) + { + return EnumerableEx.Max(source, comparer); + } +#pragma warning restore 1591 + + /// + /// Returns the elements with the maximum key value by using the default comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// List with the elements that share the same maximum key value. + public static IList MaxBy(this IQueryable source, Expression> keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.Provider.Execute>( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IList MaxBy(IEnumerable source, Func keySelector) + { + return EnumerableEx.MaxBy(source, keySelector); + } +#pragma warning restore 1591 + + /// + /// Returns the elements with the minimum key value by using the specified comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// Comparer used to determine the maximum key value. + /// List with the elements that share the same maximum key value. + public static IList MaxBy(this IQueryable source, Expression> keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.Execute>( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector, + Expression.Constant(comparer, typeof(IComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IList MaxBy(IEnumerable source, Func keySelector, IComparer comparer) + { + return EnumerableEx.MaxBy(source, keySelector, comparer); + } +#pragma warning restore 1591 + + /// + /// Shares the source sequence within a selector function where each enumerator can fetch the next element from the source sequence. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Selector function with shared access to the source sequence for each enumerator. + /// Sequence resulting from applying the selector function to the shared view over the source sequence. + public static IQueryable Share(this IQueryable source, Expression, IEnumerable>> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), + source.Expression, + selector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Share(IEnumerable source, Func, IEnumerable> selector) + { + return EnumerableEx.Share(source, selector); + } +#pragma warning restore 1591 + + /// + /// Publishes the source sequence within a selector function where each enumerator can obtain a view over a tail of the source sequence. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Selector function with published access to the source sequence for each enumerator. + /// Sequence resulting from applying the selector function to the published view over the source sequence. + public static IQueryable Publish(this IQueryable source, Expression, IEnumerable>> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), + source.Expression, + selector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Publish(IEnumerable source, Func, IEnumerable> selector) + { + return EnumerableEx.Publish(source, selector); + } +#pragma warning restore 1591 + + /// + /// Memoizes the source sequence within a selector function where each enumerator can get access to all of the sequence's elements without causing multiple enumerations over the source. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Selector function with memoized access to the source sequence for each enumerator. + /// Sequence resulting from applying the selector function to the memoized view over the source sequence. + public static IQueryable Memoize(this IQueryable source, Expression, IEnumerable>> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), + source.Expression, + selector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Memoize(IEnumerable source, Func, IEnumerable> selector) + { + return EnumerableEx.Memoize(source, selector); + } +#pragma warning restore 1591 + + /// + /// Memoizes the source sequence within a selector function where a specified number of enumerators can get access to all of the sequence's elements without causing multiple enumerations over the source. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Number of enumerators that can access the underlying buffer. Once every enumerator has obtained an element from the buffer, the element is removed from the buffer. + /// Selector function with memoized access to the source sequence for a specified number of enumerators. + /// Sequence resulting from applying the selector function to the memoized view over the source sequence. + public static IQueryable Memoize(this IQueryable source, int readerCount, Expression, IEnumerable>> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), + source.Expression, + Expression.Constant(readerCount, typeof(int)), + selector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Memoize(IEnumerable source, int readerCount, Func, IEnumerable> selector) + { + return EnumerableEx.Memoize(source, readerCount, selector); + } +#pragma warning restore 1591 + + /// + /// Creates an enumerable sequence based on an enumerator factory function. + /// + /// Result sequence element type. + /// Query provider. + /// Enumerator factory function. + /// Sequence that will invoke the enumerator factory upon a call to GetEnumerator. + public static IQueryable Create(this IQueryProvider provider, Expression>> getEnumerator) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (getEnumerator == null) + throw new ArgumentNullException("getEnumerator"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + getEnumerator + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Create(Func> getEnumerator) + { + return EnumerableEx.Create(getEnumerator); + } +#pragma warning restore 1591 + + /// + /// Returns a sequence with a single element. + /// + /// Result sequence element type. + /// Query provider. + /// Single element of the resulting sequence. + /// Sequence with a single element. + public static IQueryable Return(this IQueryProvider provider, TResult value) + { + if (provider == null) + throw new ArgumentNullException("provider"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + Expression.Constant(value, typeof(TResult)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Return(TResult value) + { + return EnumerableEx.Return(value).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Returns a sequence that throws an exception upon enumeration. + /// + /// Result sequence element type. + /// Query provider. + /// Exception to throw upon enumerating the resulting sequence. + /// Sequence that throws the specified exception upon enumeration. + public static IQueryable Throw(this IQueryProvider provider, Exception exception) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (exception == null) + throw new ArgumentNullException("exception"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + Expression.Constant(exception, typeof(Exception)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Throw(Exception exception) + { + return EnumerableEx.Throw(exception).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Creates an enumerable sequence based on an enumerable factory function. + /// + /// Result sequence element type. + /// Query provider. + /// Enumerable factory function. + /// Sequence that will invoke the enumerable factory upon a call to GetEnumerator. + public static IQueryable Defer(this IQueryProvider provider, Expression>> enumerableFactory) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (enumerableFactory == null) + throw new ArgumentNullException("enumerableFactory"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + enumerableFactory + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Defer(Func> enumerableFactory) + { + return EnumerableEx.Defer(enumerableFactory).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence by mimicking a for loop. + /// + /// State type. + /// Result sequence element type. + /// Query provider. + /// Initial state of the generator loop. + /// Loop condition. + /// State update function to run after every iteration of the generator loop. + /// Result selector to compute resulting sequence elements. + /// Sequence obtained by running the generator loop, yielding computed elements. + public static IQueryable Generate(this IQueryProvider provider, TState initialState, Expression> condition, Expression> iterate, Expression> resultSelector) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (condition == null) + throw new ArgumentNullException("condition"); + if (iterate == null) + throw new ArgumentNullException("iterate"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TState), typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + Expression.Constant(initialState), + condition, + iterate, + resultSelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Generate(TState initialState, Func condition, Func iterate, Func resultSelector) + { + return EnumerableEx.Generate(initialState, condition, iterate, resultSelector).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage duration. + /// + /// Source element type. + /// Resource type. + /// Query provider. + /// Resource factory function. + /// Enumerable factory function, having access to the obtained resource. + /// Sequence whose use controls the lifetime of the associated obtained resource. + public static IQueryable Using(this IQueryProvider provider, Expression> resourceFactory, Expression>> enumerableFactory) where TResource : IDisposable + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (resourceFactory == null) + throw new ArgumentNullException("resourceFactory"); + if (enumerableFactory == null) + throw new ArgumentNullException("enumerableFactory"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResource)), + Expression.Constant(provider, typeof(IQueryProvider)), + resourceFactory, + enumerableFactory + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Using(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable + { + return EnumerableEx.Using(resourceFactory, enumerableFactory).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence by repeating the given value infinitely. + /// + /// Result sequence element type. + /// Query provider. + /// Value to repreat in the resulting sequence. + /// Sequence repeating the given value infinitely. + public static IEnumerable Repeat(this IQueryProvider provider, TResult value) + { + if (provider == null) + throw new ArgumentNullException("provider"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + Expression.Constant(value, typeof(TResult)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Repeat(TResult value) + { + return EnumerableEx.Repeat(value).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error. + /// + /// Source sequence element type. + /// Exception type to catch. + /// Source sequence. + /// Handler to invoke when an exception of the specified type occurs. + /// Source sequence, concatenated with an exception handler result sequence in case of an error. + public static IQueryable Catch(this IQueryable source, Expression>> handler) + where TException : Exception + { + if (source == null) + throw new ArgumentNullException("source"); + if (handler == null) + throw new ArgumentNullException("handler"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TException)), + source.Expression, + handler + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Catch(IEnumerable source, Func> handler) + where TException : Exception + { + return EnumerableEx.Catch(source, handler); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence that continues to concatenate source sequences while errors occur. + public static IQueryable Catch(this IQueryable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + sources.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Catch(IEnumerable> sources) + { + return EnumerableEx.Catch(sources); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. + /// + /// Source sequence element type. + /// Query provider. + /// Source sequences. + /// Sequence that continues to concatenate source sequences while errors occur. + public static IQueryable Catch(this IQueryProvider provider, params IEnumerable[] sources) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (sources == null) + throw new ArgumentNullException("sources"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + Expression.Constant(provider, typeof(IQueryProvider)), + GetSourceExpression(sources) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Catch(params IEnumerable[] sources) + { + return EnumerableEx.Catch(sources).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error. + /// + /// Source sequence element type. + /// First sequence. + /// Second sequence, concatenated to the result in case the first sequence completes exceptionally. + /// The first sequence, followed by the second sequence in case an error is produced. + public static IQueryable Catch(this IQueryable first, IEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return first.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + first.Expression, + GetSourceExpression(second) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Catch(IEnumerable first, IEnumerable second) + { + return EnumerableEx.Catch(first, second); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to run upon termination of the sequence, or when an enumerator is disposed. + /// Source sequence with guarantees on the invocation of the finally action. + public static IQueryable Finally(this IQueryable source, Expression finallyAction) + { + if (source == null) + throw new ArgumentNullException("source"); + if (finallyAction == null) + throw new ArgumentNullException("finallyAction"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + finallyAction + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Finally(IEnumerable source, Action finallyAction) + { + return EnumerableEx.Finally(source, finallyAction); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that concatenates both given sequences, regardless of whether an error occurs. + /// + /// Source sequence element type. + /// First sequence. + /// Second sequence. + /// Sequence concatenating the elements of both sequences, ignoring errors. + public static IQueryable OnErrorResumeNext(this IQueryable first, IEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return first.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + first.Expression, + GetSourceExpression(second) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable OnErrorResumeNext(IEnumerable first, IEnumerable second) + { + return EnumerableEx.OnErrorResumeNext(first, second); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. + /// + /// Source sequence element type. + /// Query provider. + /// Source sequences. + /// Sequence concatenating the elements of the given sequences, ignoring errors. + public static IEnumerable OnErrorResumeNext(this IQueryProvider provider, params IEnumerable[] sources) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (sources == null) + throw new ArgumentNullException("sources"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + Expression.Constant(provider, typeof(IQueryProvider)), + GetSourceExpression(sources) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable OnErrorResumeNext(params IEnumerable[] sources) + { + return EnumerableEx.OnErrorResumeNext(sources).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence concatenating the elements of the given sequences, ignoring errors. + public static IQueryable OnErrorResumeNext(this IQueryable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + sources.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable OnErrorResumeNext(IEnumerable> sources) + { + return EnumerableEx.OnErrorResumeNext(sources); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that retries enumerating the source sequence as long as an error occurs. + /// + /// Source sequence element type. + /// Source sequence. + /// Sequence concatenating the results of the source sequence as long as an error occurs. + public static IQueryable Retry(this IQueryable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Retry(IEnumerable source) + { + return EnumerableEx.Retry(source); + } +#pragma warning restore 1591 + + /// + /// Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified maximum number of retries. + /// + /// Source sequence element type. + /// Source sequence. + /// Maximum number of retries. + /// Sequence concatenating the results of the source sequence as long as an error occurs. + public static IQueryable Retry(this IQueryable source, int retryCount) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(retryCount, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Retry(IEnumerable source, int retryCount) + { + return EnumerableEx.Retry(source, retryCount); + } +#pragma warning restore 1591 + + /// + /// Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. + /// + /// Result sequence element type. + /// Query provider. + /// Loop condition. + /// Sequence to repeat while the condition evaluates true. + /// Sequence generated by repeating the given sequence while the condition evaluates to true. + public static IQueryable While(this IQueryProvider provider, Expression> condition, IEnumerable source) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (condition == null) + throw new ArgumentNullException("condition"); + if (source == null) + throw new ArgumentNullException("source"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + condition, + GetSourceExpression(source) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable While(Func condition, IEnumerable source) + { + return EnumerableEx.While(condition, source).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Returns an enumerable sequence based on the evaluation result of the given condition. + /// + /// Result sequence element type. + /// Query provider. + /// Condition to evaluate. + /// Sequence to return in case the condition evaluates true. + /// Sequence to return in case the condition evaluates false. + /// Either of the two input sequences based on the result of evaluating the condition. + public static IQueryable If(this IQueryProvider provider, Expression> condition, IEnumerable thenSource, IEnumerable elseSource) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (condition == null) + throw new ArgumentNullException("condition"); + if (thenSource == null) + throw new ArgumentNullException("thenSource"); + if (elseSource == null) + throw new ArgumentNullException("elseSource"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + condition, + GetSourceExpression(thenSource), + GetSourceExpression(elseSource) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable If(Func condition, IEnumerable thenSource, IEnumerable elseSource) + { + return EnumerableEx.If(condition, thenSource, elseSource).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. + /// + /// Result sequence element type. + /// Query provider. + /// Condition to evaluate. + /// Sequence to return in case the condition evaluates true. + /// The given input sequence if the condition evaluates true; otherwise, an empty sequence. + public static IQueryable If(this IQueryProvider provider, Expression> condition, IEnumerable thenSource) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (condition == null) + throw new ArgumentNullException("condition"); + if (thenSource == null) + throw new ArgumentNullException("thenSource"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + condition, + GetSourceExpression(thenSource) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable If(Func condition, IEnumerable thenSource) + { + return EnumerableEx.If(condition, thenSource).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. + /// + /// Result sequence element type. + /// Source sequence to repeat while the condition evaluates true. + /// Loop condition. + /// Sequence generated by repeating the given sequence until the condition evaluates to false. + public static IQueryable DoWhile(this IQueryable source, Expression> condition) + { + if (source == null) + throw new ArgumentNullException("source"); + if (condition == null) + throw new ArgumentNullException("condition"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + source.Expression, + condition + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable DoWhile(IEnumerable source, Func condition) + { + return EnumerableEx.DoWhile(source, condition); + } +#pragma warning restore 1591 + + /// + /// Returns a sequence from a dictionary based on the result of evaluating a selector function. + /// + /// Type of the selector value. + /// Result sequence element type. + /// Query provider. + /// Selector function used to pick a sequence from the given sources. + /// Dictionary mapping selector values onto resulting sequences. + /// The source sequence corresponding with the evaluated selector value; otherwise, an empty sequence. + public static IQueryable Case(this IQueryProvider provider, Expression> selector, IDictionary> sources) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (selector == null) + throw new ArgumentNullException("selector"); + if (sources == null) + throw new ArgumentNullException("sources"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TValue), typeof(TResult)), + selector, + Expression.Constant(sources, typeof(IDictionary>)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Case(Func selector, IDictionary> sources) + { + return EnumerableEx.Case(selector, sources).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Returns a sequence from a dictionary based on the result of evaluating a selector function, also specifying a default sequence. + /// + /// Type of the selector value. + /// Result sequence element type. + /// Query provider. + /// Selector function used to pick a sequence from the given sources. + /// Dictionary mapping selector values onto resulting sequences. + /// Default sequence to return in case there's no corresponding source for the computed selector value. + /// The source sequence corresponding with the evaluated selector value; otherwise, the default source. + public static IQueryable Case(this IQueryProvider provider, Expression> selector, IDictionary> sources, IEnumerable defaultSource) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (selector == null) + throw new ArgumentNullException("selector"); + if (sources == null) + throw new ArgumentNullException("sources"); + if (defaultSource == null) + throw new ArgumentNullException("defaultSource"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TValue), typeof(TResult)), + selector, + Expression.Constant(sources, typeof(IDictionary>)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Case(Func selector, IDictionary> sources, IEnumerable defaultSource) + { + return EnumerableEx.Case(selector, sources, defaultSource).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence by enumerating a source sequence, mapping its elements on result sequences, and concatenating those sequences. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Query provider. + /// Source sequence. + /// Result selector to evaluate for each iteration over the source. + /// Sequence concatenating the inner sequences that result from evaluating the result selector on elements from the source. + public static IQueryable For(this IQueryProvider provider, IEnumerable source, Expression>> resultSelector) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (source == null) + throw new ArgumentNullException("source"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), + GetSourceExpression(source), + resultSelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable For(IEnumerable source, Func> resultSelector) + { + return EnumerableEx.For(source, resultSelector).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Concatenates the input sequences. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence with the elements of the source sequences concatenated. + public static IQueryable Concat(this IQueryable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + GetSourceExpression(sources) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Concat(IEnumerable> sources) + { + return EnumerableEx.Concat(sources); + } +#pragma warning restore 1591 + + /// + /// Concatenates the input sequences. + /// + /// Source sequence element type. + /// Query provider. + /// Source sequences. + /// Sequence with the elements of the source sequences concatenated. + public static IQueryable Concat(this IQueryProvider provider, params IEnumerable[] sources) + { + if (provider == null) + throw new ArgumentNullException("provider"); + if (sources == null) + throw new ArgumentNullException("sources"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + Expression.Constant(provider, typeof(IQueryProvider)), + GetSourceExpression(sources) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Concat(params IEnumerable[] sources) + { + return EnumerableEx.Concat(sources).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Projects each element of a sequence to an given sequence and flattens the resulting sequences into one sequence. + /// + /// First source sequence element type. + /// Second source sequence element type. + /// A sequence of values to project. + /// Inner sequence each source sequenec element is projected onto. + /// Sequence flattening the sequences that result from projecting elements in the source sequence. + public static IQueryable SelectMany(this IQueryable source, IEnumerable other) + { + if (source == null) + throw new ArgumentNullException("source"); + if (other == null) + throw new ArgumentNullException("other"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TOther)), + source.Expression, + GetSourceExpression(other) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable SelectMany(IEnumerable source, IEnumerable other) + { + return EnumerableEx.SelectMany(source, other); + } +#pragma warning restore 1591 + +#if NO_ZIP + /// + /// Merges two sequences by applying the specified selector function on index-based corresponding element pairs from both sequences. + /// + /// The type of the elements of the first input sequence. + /// The type of the elements of the second input sequence. + /// The type of the elements of the result sequence. + /// The first sequence to merge. + /// The second sequence to merge. + /// Function to apply to each pair of elements from both sequences. + /// Sequence consisting of the result of pairwise application of the selector function over pairs of elements from the source sequences. + public static IQueryable Zip(this IQueryable first, IEnumerable second, Expression> resultSelector) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return first.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TResult)), + first.Expression, + GetSourceExpression(second), + resultSelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Zip(IEnumerable first, IEnumerable second, Func resultSelector) + { + return EnumerableEx.Zip(first, second, resultSelector); + } +#pragma warning restore 1591 +#endif + + /// + /// Hides the enumerable sequence object identity. + /// + /// Source sequence element type. + /// Source sequence. + /// Enumerable sequence with the same behavior as the original, but hiding the source object identity. + /// AsQueryable doesn't hide the object identity, and simply acts as a cast to the IQueryable<TSource> interface. + public static IQueryable Hide(this IQueryable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Hide(IEnumerable source) + { + return EnumerableEx.Hide(source); + } +#pragma warning restore 1591 + + /// + /// Lazily invokes an action for each value in the sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IQueryable Do(this IQueryable source, Expression> onNext) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + onNext + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Do(IEnumerable source, Action onNext) + { + return EnumerableEx.Do(source, onNext); + } +#pragma warning restore 1591 + + /// + /// Lazily invokes an action for each value in the sequence, and executes an action for successful termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Action to invoke on successful termination of the sequence. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IQueryable Do(this IQueryable source, Expression> onNext, Expression onCompleted) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onCompleted == null) + throw new ArgumentNullException("onCompleted"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + onNext, + onCompleted + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Do(IEnumerable source, Action onNext, Action onCompleted) + { + return EnumerableEx.Do(source, onNext, onCompleted); + } +#pragma warning restore 1591 + + /// + /// Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Action to invoke on exceptional termination of the sequence. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IQueryable Do(this IQueryable source, Expression> onNext, Expression> onError) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onError == null) + throw new ArgumentNullException("onError"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + onNext, + onError + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Do(IEnumerable source, Action onNext, Action onError) + { + return EnumerableEx.Do(source, onNext, onError); + } +#pragma warning restore 1591 + + /// + /// Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Action to invoke on exceptional termination of the sequence. + /// Action to invoke on successful termination of the sequence. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IQueryable Do(this IQueryable source, Expression> onNext, Expression> onError, Expression onCompleted) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onError == null) + throw new ArgumentNullException("onError"); + if (onCompleted == null) + throw new ArgumentNullException("onCompleted"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + onNext, + onError, + onCompleted + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Do(IEnumerable source, Action onNext, Action onError, Action onCompleted) + { + return EnumerableEx.Do(source, onNext, onError, onCompleted); + } +#pragma warning restore 1591 + +#if !NO_RXINTERFACES + /// + /// Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Observer to invoke notification calls on. + /// Sequence exhibiting the side-effects of observer method invocation upon enumeration. + public static IQueryable Do(this IQueryable source, IObserver observer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (observer == null) + throw new ArgumentNullException("observer"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(observer, typeof(IObserver)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Do(IEnumerable source, IObserver observer) + { + return EnumerableEx.Do(source, observer); + } +#pragma warning restore 1591 +#endif + + /// + /// Generates a sequence of non-overlapping adjacent buffers over the source sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of elements for allocated buffers. + /// Sequence of buffers containing source sequence elements. + public static IQueryable> Buffer(this IQueryable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery>( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(count, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable> Buffer(IEnumerable source, int count) + { + return EnumerableEx.Buffer(source, count); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence of buffers over the source sequence, with specified length and possible overlap. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of elements for allocated buffers. + /// Number of elements to skip between the start of consecutive buffers. + /// Sequence of buffers containing source sequence elements. + public static IQueryable> Buffer(this IQueryable source, int count, int skip) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery>( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(count, typeof(int)), + Expression.Constant(skip, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable> Buffer(IEnumerable source, int count, int skip) + { + return EnumerableEx.Buffer(source, count, skip); + } +#pragma warning restore 1591 + + /// + /// Ignores all elements in the source sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Source sequence without its elements. + public static IQueryable IgnoreElements(this IQueryable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable IgnoreElements(IEnumerable source) + { + return EnumerableEx.IgnoreElements(source); + } +#pragma warning restore 1591 + + /// + /// Returns elements with a distinct key value by using the default equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Sequence that contains the elements from the source sequence with distinct key values. + public static IQueryable Distinct(this IQueryable source, Expression> keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Distinct(IEnumerable source, Func keySelector) + { + return EnumerableEx.Distinct(source, keySelector); + } +#pragma warning restore 1591 + + /// + /// Returns elements with a distinct key value by using the specified equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Comparer used to compare key values. + /// Sequence that contains the elements from the source sequence with distinct key values. + public static IQueryable Distinct(this IQueryable source, Expression> keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector, + Expression.Constant(comparer, typeof(IEqualityComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Distinct(IEnumerable source, Func keySelector, IEqualityComparer comparer) + { + return EnumerableEx.Distinct(source, keySelector, comparer); + } +#pragma warning restore 1591 + + /// + /// Returns consecutive distinct elements by using the default equality comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Sequence without adjacent non-distinct elements. + public static IQueryable DistinctUntilChanged(this IQueryable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable DistinctUntilChanged(IEnumerable source) + { + return EnumerableEx.DistinctUntilChanged(source); + } +#pragma warning restore 1591 + + /// + /// Returns consecutive distinct elements by using the specified equality comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Comparer used to compare values. + /// Sequence without adjacent non-distinct elements. + public static IQueryable DistinctUntilChanged(this IQueryable source, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(comparer, typeof(IEqualityComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable DistinctUntilChanged(IEnumerable source, IEqualityComparer comparer) + { + return EnumerableEx.DistinctUntilChanged(source, comparer); + } +#pragma warning restore 1591 + + /// + /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Sequence without adjacent non-distinct elements. + public static IQueryable DistinctUntilChanged(this IQueryable source, Expression> keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable DistinctUntilChanged(IEnumerable source, Func keySelector) + { + return EnumerableEx.DistinctUntilChanged(source, keySelector); + } +#pragma warning restore 1591 + + /// + /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Comparer used to compare key values. + /// Sequence without adjacent non-distinct elements. + public static IQueryable DistinctUntilChanged(this IQueryable source, Expression> keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), + source.Expression, + keySelector, + Expression.Constant(comparer, typeof(IEqualityComparer)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable DistinctUntilChanged(IEnumerable source, Func keySelector, IEqualityComparer comparer) + { + return EnumerableEx.DistinctUntilChanged(source, keySelector, comparer); + } +#pragma warning restore 1591 + + /// + /// Expands the sequence by recursively applying a selector function. + /// + /// Source sequence element type. + /// Source sequence. + /// Selector function to retrieve the next sequence to expand. + /// Sequence with results from the recursive expansion of the source sequence. + public static IQueryable Expand(this IQueryable source, Expression>> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + selector + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Expand(IEnumerable source, Func> selector) + { + return EnumerableEx.Expand(source, selector); + } +#pragma warning restore 1591 + + /// + /// Returns the source sequence prefixed with the specified value. + /// + /// Source sequence element type. + /// Source sequence. + /// Values to prefix the sequence with. + /// Sequence starting with the specified prefix value, followed by the source sequence. + public static IQueryable StartWith(this IQueryable source, params TSource[] values) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(values, typeof(TSource[])) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable StartWith(IEnumerable source, params TSource[] values) + { + return EnumerableEx.StartWith(source, values); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. + /// + /// Source sequence element type. + /// Accumulation type. + /// Source sequence. + /// Accumulator seed value. + /// Accumulation function to apply to the current accumulation value and each element of the sequence. + /// Sequence with all intermediate accumulation values resulting from scanning the sequence. + public static IQueryable Scan(this IQueryable source, TAccumulate seed, Expression> accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TAccumulate)), + source.Expression, + Expression.Constant(seed, typeof(TAccumulate)), + accumulator + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Scan(IEnumerable source, TAccumulate seed, Func accumulator) + { + return EnumerableEx.Scan(source, seed, accumulator); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. + /// + /// Source sequence element type. + /// Source sequence. + /// Accumulation function to apply to the current accumulation value and each element of the sequence. + /// Sequence with all intermediate accumulation values resulting from scanning the sequence. + public static IQueryable Scan(this IQueryable source, Expression> accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + accumulator + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Scan(IEnumerable source, Func accumulator) + { + return EnumerableEx.Scan(source, accumulator); + } +#pragma warning restore 1591 + + /// + /// Returns a specified number of contiguous elements from the end of the sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// The number of elements to take from the end of the sequence. + /// Sequence with the specified number of elements counting from the end of the source sequence. + public static IQueryable TakeLast(this IQueryable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(count, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable TakeLast(IEnumerable source, int count) + { + return EnumerableEx.TakeLast(source, count); + } +#pragma warning restore 1591 + + /// + /// Bypasses a specified number of contiguous elements from the end of the sequence and returns the remaining elements. + /// + /// Source sequence element type. + /// Source sequence. + /// The number of elements to skip from the end of the sequence before returning the remaining elements. + /// Sequence bypassing the specified number of elements counting from the end of the source sequence. + public static IQueryable SkipLast(this IQueryable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(count, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable SkipLast(IEnumerable source, int count) + { + return EnumerableEx.SkipLast(source, count); + } +#pragma warning restore 1591 + + /// + /// Repeats and concatenates the source sequence infinitely. + /// + /// Source sequence element type. + /// Source sequence. + /// Sequence obtained by concatenating the source sequence to itself infinitely. + public static IQueryable Repeat(this IQueryable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Repeat(IEnumerable source) + { + return EnumerableEx.Repeat(source); + } +#pragma warning restore 1591 + + /// + /// Repeats and concatenates the source sequence the given number of times. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of times to repeat the source sequence. + /// Sequence obtained by concatenating the source sequence to itself the specified number of times. + public static IQueryable Repeat(this IQueryable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), + source.Expression, + Expression.Constant(count, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static IEnumerable Repeat(IEnumerable source, int count) + { + return EnumerableEx.Repeat(source, count); + } +#pragma warning restore 1591 + + /// + /// Returns a sequence with no elements. + /// + /// Result sequence element type. + /// Query provider. + /// Sequence with no elements. + public static IQueryable Empty(this IQueryProvider provider) + { + if (provider == null) + throw new ArgumentNullException("provider"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Empty() + { + return Enumerable.Empty().AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence of integral numbers within a specified range. + /// + /// Query provider. + /// The value of the first integer in the sequence. + /// The number of sequential integers to generate. + /// Sequence that contains a range of sequential integral numbers. + public static IQueryable Range(this IQueryProvider provider, int start, int count) + { + if (provider == null) + throw new ArgumentNullException("provider"); + + return provider.CreateQuery( + Expression.Call( + null, + (MethodInfo)MethodInfo.GetCurrentMethod(), + Expression.Constant(provider, typeof(IQueryProvider)), + Expression.Constant(start, typeof(int)), + Expression.Constant(count, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Range(int start, int count) + { + return Enumerable.Range(start, count).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Generates a sequence that contains one repeated value. + /// + /// Result sequence element type. + /// Query provider. + /// The value to be repeated. + /// The number of times to repeat the value in the generated sequence. + /// Sequence that contains a repeated value. + public static IQueryable Repeat(this IQueryProvider provider, TResult element, int count) + { + if (provider == null) + throw new ArgumentNullException("provider"); + + return provider.CreateQuery( + Expression.Call( + null, + ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), + Expression.Constant(provider, typeof(IQueryProvider)), + Expression.Constant(element, typeof(TResult)), + Expression.Constant(count, typeof(int)) + ) + ); + } + +#pragma warning disable 1591 + [EditorBrowsable(EditorBrowsableState.Never)] + public static /*!*/IQueryable Repeat(TResult element, int count) + { + return EnumerableEx.Repeat(element, count).AsQueryable(); + } +#pragma warning restore 1591 + + /// + /// Gets the local Queryable provider. + /// + public static IQueryProvider Provider + { + get + { + return new QueryProviderShim(); + } + } + + class QueryProviderShim : IQueryProvider + { + public IQueryable CreateQuery(Expression expression) + { + var provider = new TElement[0].AsQueryable().Provider; + var res = Redir(expression); + return provider.CreateQuery(res); + } + + public IQueryable CreateQuery(Expression expression) + { + return CreateQuery(expression); + } + + public TResult Execute(Expression expression) + { + var provider = new TResult[0].AsQueryable().Provider; + var res = Redir(expression); + return provider.Execute(res); + } + + public object Execute(Expression expression) + { + return Execute(expression); + } + + private static Expression Redir(Expression expression) + { + var mce = expression as MethodCallExpression; + if (mce != null && mce.Method.DeclaringType == typeof(QueryableEx)) + { + if (mce.Arguments.Count >= 1 && typeof(IQueryProvider).IsAssignableFrom(mce.Arguments[0].Type)) + { + var ce = mce.Arguments[0] as ConstantExpression; + if (ce != null) + { + if (ce.Value is QueryProviderShim) + { + var targetType = typeof(QueryableEx); + var method = mce.Method; + var methods = GetMethods(targetType); + var arguments = mce.Arguments.Skip(1).ToList(); + + // + // From all the operators with the method's name, find the one that matches all arguments. + // + var typeArgs = method.IsGenericMethod ? method.GetGenericArguments() : null; + var targetMethod = methods[method.Name].FirstOrDefault(candidateMethod => ArgsMatch(candidateMethod, arguments, typeArgs)); + if (targetMethod == null) + throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "There is no method '{0}' on type '{1}' that matches the specified arguments", method.Name, targetType.Name)); + + // + // Restore generic arguments. + // + if (typeArgs != null) + targetMethod = targetMethod.MakeGenericMethod(typeArgs); + + // + // Finally, we need to deal with mismatches on Expression> versus Func<...>. + // + var parameters = targetMethod.GetParameters(); + for (int i = 0, n = parameters.Length; i < n; i++) + { + arguments[i] = Unquote(arguments[i]); + } + + // + // Emit a new call to the discovered target method. + // + return Expression.Call(null, targetMethod, arguments); + } + } + } + } + + return expression; + } + + private static ILookup GetMethods(Type type) + { + return type.GetMethods(BindingFlags.Static | BindingFlags.Public).ToLookup(m => m.Name); + } + + private static bool ArgsMatch(MethodInfo method, IList arguments, Type[] typeArgs) + { + // + // Number of parameters should match. Notice we've sanitized IQueryProvider "this" + // parameters first (see Redir). + // + var parameters = method.GetParameters(); + if (parameters.Length != arguments.Count) + return false; + + // + // Genericity should match too. + // + if (!method.IsGenericMethod && typeArgs != null && typeArgs.Length > 0) + return false; + + // + // Reconstruct the generic method if needed. + // + if (method.IsGenericMethodDefinition) + { + if (typeArgs == null) + return false; + + if (method.GetGenericArguments().Length != typeArgs.Length) + return false; + + var result = method.MakeGenericMethod(typeArgs); + parameters = result.GetParameters(); + } + + // + // Check compatibility for the parameter types. + // + for (int i = 0, n = arguments.Count; i < n; i++) + { + var parameterType = parameters[i].ParameterType; + var argument = arguments[i]; + + // + // For operators that take a function (like Where, Select), we'll be faced + // with a quoted argument and a discrepancy between Expression> + // and the underlying Func<...>. + // + if (!parameterType.IsAssignableFrom(argument.Type)) + { + argument = Unquote(argument); + if (!parameterType.IsAssignableFrom(argument.Type)) + return false; + } + } + + return true; + } + + private static Expression Unquote(Expression expression) + { + // + // Get rid of all outer quotes around an expression. + // + while (expression.NodeType == ExpressionType.Quote) + expression = ((UnaryExpression)expression).Operand; + + return expression; + } + } + + internal static Expression GetSourceExpression(IEnumerable source) + { + var q = source as IQueryable; + if (q != null) + return q.Expression; + + return Expression.Constant(source, typeof(IEnumerable)); + } + + internal static Expression GetSourceExpression(IEnumerable[] sources) + { + return Expression.NewArrayInit( + typeof(IEnumerable), + sources.Select(source => GetSourceExpression(source)) + ); + } + } +} diff --git a/Ix/System.Interactive.Providers/System.Interactive.Providers.csproj b/Ix/System.Interactive.Providers/System.Interactive.Providers.csproj new file mode 100644 index 0000000..839f290 --- /dev/null +++ b/Ix/System.Interactive.Providers/System.Interactive.Providers.csproj @@ -0,0 +1,41 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {6D62E966-469D-4A99-BD43-0A17FA14FB4F} + Library + Properties + System.Interactive.Providers + System.Interactive.Providers + v4.0 + 512 + true + + + + $(OutputPath)\$(AssemblyName).XML + + + Profile1 + + + + + + + + + + + + + + {8E4B04F0-915E-48F9-9796-76278C6094BD} + System.Interactive + + + + \ No newline at end of file diff --git a/Ix/System.Interactive/EnumerableEx.Aggregates.cs b/Ix/System.Interactive/EnumerableEx.Aggregates.cs new file mode 100644 index 0000000..204d5ee --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Aggregates.cs @@ -0,0 +1,173 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; + +namespace System.Linq +{ + /// + /// Provides a set of additional static methods that allow querying enumerable sequences. + /// + public static partial class EnumerableEx + { + /// + /// Determines whether an enumerable sequence is empty. + /// + /// Source sequence element type. + /// Source sequence. + /// true if the sequence is empty; false otherwise. + public static bool IsEmpty(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return !source.Any(); + } + + /// + /// Returns the minimum value in the enumerable sequence by using the specified comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Comparer used to determine the minimum value. + /// Minimum value in the sequence. + public static TSource Min(this IEnumerable source, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return MinBy(source, x => x, comparer).First(); + } + + /// + /// Returns the elements with the minimum key value by using the default comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// List with the elements that share the same minimum key value. + public static IList MinBy(this IEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return MinBy(source, keySelector, Comparer.Default); + } + + /// + /// Returns the elements with the minimum key value by using the specified comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// Comparer used to determine the minimum key value. + /// List with the elements that share the same minimum key value. + public static IList MinBy(this IEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ExtremaBy(source, keySelector, (key, minValue) => -comparer.Compare(key, minValue)); + } + + /// + /// Returns the maximum value in the enumerable sequence by using the specified comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Comparer used to determine the maximum value. + /// Maximum value in the sequence. + public static TSource Max(this IEnumerable source, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return MaxBy(source, x => x, comparer).First(); + } + + /// + /// Returns the elements with the maximum key value by using the default comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// List with the elements that share the same maximum key value. + public static IList MaxBy(this IEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return MaxBy(source, keySelector, Comparer.Default); + } + + /// + /// Returns the elements with the minimum key value by using the specified comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector used to extract the key for each element in the sequence. + /// Comparer used to determine the maximum key value. + /// List with the elements that share the same maximum key value. + public static IList MaxBy(this IEnumerable source, Func keySelector, IComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return ExtremaBy(source, keySelector, (key, minValue) => comparer.Compare(key, minValue)); + } + + private static IList ExtremaBy(IEnumerable source, Func keySelector, Func compare) + { + var result = new List(); + + using (var e = source.GetEnumerator()) + { + if (!e.MoveNext()) + throw new InvalidOperationException("Source sequence doesn't contain any elements."); + + var current = e.Current; + var resKey = keySelector(current); + result.Add(current); + + while (e.MoveNext()) + { + var cur = e.Current; + var key = keySelector(cur); + + var cmp = compare(key, resKey); + if (cmp == 0) + { + result.Add(cur); + } + else if (cmp > 0) + { + result = new List { cur }; + resKey = key; + } + } + } + + return result; + } + } +} diff --git a/Ix/System.Interactive/EnumerableEx.Buffering.cs b/Ix/System.Interactive/EnumerableEx.Buffering.cs new file mode 100644 index 0000000..35785bf --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Buffering.cs @@ -0,0 +1,647 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Diagnostics; + +namespace System.Linq +{ + public static partial class EnumerableEx + { + /// + /// Creates a buffer with a shared view over the source sequence, causing each enumerator to fetch the next element from the source sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Buffer enabling each enumerator to retrieve elements from the shared source sequence. + /// + /// var rng = Enumerable.Range(0, 10).Share(); + /// + /// var e1 = rng.GetEnumerator(); // Both e1 and e2 will consume elements from + /// var e2 = rng.GetEnumerator(); // the source sequence. + /// + /// Assert.IsTrue(e1.MoveNext()); + /// Assert.AreEqual(0, e1.Current); + /// + /// Assert.IsTrue(e1.MoveNext()); + /// Assert.AreEqual(1, e1.Current); + /// + /// Assert.IsTrue(e2.MoveNext()); // e2 "steals" element 2 + /// Assert.AreEqual(2, e2.Current); + /// + /// Assert.IsTrue(e1.MoveNext()); // e1 can't see element 2 + /// Assert.AreEqual(3, e1.Current); + /// + public static IBuffer Share(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return new SharedBuffer(source.GetEnumerator()); + } + + /// + /// Shares the source sequence within a selector function where each enumerator can fetch the next element from the source sequence. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Selector function with shared access to the source sequence for each enumerator. + /// Sequence resulting from applying the selector function to the shared view over the source sequence. + public static IEnumerable Share(this IEnumerable source, Func, IEnumerable> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => selector(source.Share()).GetEnumerator()); + } + + class SharedBuffer : IBuffer + { + private IEnumerator _source; + private bool _disposed; + + public SharedBuffer(IEnumerator source) + { + _source = source; + } + + public IEnumerator GetEnumerator() + { + if (_disposed) + throw new ObjectDisposedException(""); + + return GetEnumerator_(); + } + + private IEnumerator GetEnumerator_() + { + while (true) + { + if (_disposed) + throw new ObjectDisposedException(""); + + var hasValue = default(bool); + var current = default(T); + + lock (_source) + { + hasValue = _source.MoveNext(); + if (hasValue) + current = _source.Current; + } + + if (hasValue) + yield return current; + else + break; + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + if (_disposed) + throw new ObjectDisposedException(""); + + return GetEnumerator(); + } + + public void Dispose() + { + lock (_source) + { + if (!_disposed) + { + _source.Dispose(); + _source = null; + } + + _disposed = true; + } + } + } + + /// + /// Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of the sequence from the current index in the buffer. + /// + /// Source sequence element type. + /// Source sequence. + /// Buffer enabling each enumerator to retrieve elements from the shared source sequence, starting from the index at the point of obtaining the enumerator. + /// + /// var rng = Enumerable.Range(0, 10).Publish(); + /// + /// var e1 = rng.GetEnumerator(); // e1 has a view on the source starting from element 0 + /// + /// Assert.IsTrue(e1.MoveNext()); + /// Assert.AreEqual(0, e1.Current); + /// + /// Assert.IsTrue(e1.MoveNext()); + /// Assert.AreEqual(1, e1.Current); + /// + /// var e2 = rng.GetEnumerator(); + /// + /// Assert.IsTrue(e2.MoveNext()); // e2 has a view on the source starting from element 2 + /// Assert.AreEqual(2, e2.Current); + /// + /// Assert.IsTrue(e1.MoveNext()); // e1 continues to enumerate over its view + /// Assert.AreEqual(2, e1.Current); + /// + public static IBuffer Publish(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return new PublishedBuffer(source.GetEnumerator()); + } + + /// + /// Publishes the source sequence within a selector function where each enumerator can obtain a view over a tail of the source sequence. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Selector function with published access to the source sequence for each enumerator. + /// Sequence resulting from applying the selector function to the published view over the source sequence. + public static IEnumerable Publish(this IEnumerable source, Func, IEnumerable> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => selector(source.Publish()).GetEnumerator()); + } + + class PublishedBuffer : IBuffer + { + private IEnumerator _source; + private RefCountList _buffer; + private bool _stopped; + private Exception _error; + private bool _disposed; + + public PublishedBuffer(IEnumerator source) + { + _buffer = new RefCountList(0); + _source = source; + } + + public IEnumerator GetEnumerator() + { + if (_disposed) + throw new ObjectDisposedException(""); + + var i = default(int); + lock (_source) + { + i = _buffer.Count; + _buffer.ReaderCount++; + } + + return GetEnumerator_(i); + } + + private IEnumerator GetEnumerator_(int i) + { + try + { + while (true) + { + if (_disposed) + throw new ObjectDisposedException(""); + + var hasValue = default(bool); + var current = default(T); + + lock (_source) + { + if (i >= _buffer.Count) + { + if (!_stopped) + { + try + { + hasValue = _source.MoveNext(); + if (hasValue) + current = _source.Current; + } + catch (Exception ex) + { + _stopped = true; + _error = ex; + + _source.Dispose(); + } + } + + if (_stopped) + { + if (_error != null) + throw _error; + else + break; + } + + if (hasValue) + { + _buffer.Add(current); + } + } + else + { + hasValue = true; + } + } + + if (hasValue) + yield return _buffer[i]; + else + break; + + i++; + } + } + finally + { + if (_buffer != null) + _buffer.Done(i + 1); + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + if (_disposed) + throw new ObjectDisposedException(""); + + return GetEnumerator(); + } + + public void Dispose() + { + lock (_source) + { + if (!_disposed) + { + _source.Dispose(); + _source = null; + + _buffer.Clear(); + _buffer = null; + } + + _disposed = true; + } + } + } + + /// + /// Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to all of the sequence's elements without causing multiple enumerations over the source. + /// + /// Source sequence element type. + /// Source sequence. + /// Buffer enabling each enumerator to retrieve all elements from the shared source sequence, without duplicating source enumeration side-effects. + /// + /// var rng = Enumerable.Range(0, 10).Do(x => Console.WriteLine(x)).Memoize(); + /// + /// var e1 = rng.GetEnumerator(); + /// + /// Assert.IsTrue(e1.MoveNext()); // Prints 0 + /// Assert.AreEqual(0, e1.Current); + /// + /// Assert.IsTrue(e1.MoveNext()); // Prints 1 + /// Assert.AreEqual(1, e1.Current); + /// + /// var e2 = rng.GetEnumerator(); + /// + /// Assert.IsTrue(e2.MoveNext()); // Doesn't print anything; the side-effect of Do + /// Assert.AreEqual(0, e2.Current); // has already taken place during e1's iteration. + /// + /// Assert.IsTrue(e1.MoveNext()); // Prints 2 + /// Assert.AreEqual(2, e1.Current); + /// + public static IBuffer Memoize(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return new MemoizedBuffer(source.GetEnumerator()); + } + + /// + /// Memoizes the source sequence within a selector function where each enumerator can get access to all of the sequence's elements without causing multiple enumerations over the source. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Selector function with memoized access to the source sequence for each enumerator. + /// Sequence resulting from applying the selector function to the memoized view over the source sequence. + public static IEnumerable Memoize(this IEnumerable source, Func, IEnumerable> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => selector(source.Memoize()).GetEnumerator()); + } + + /// + /// Creates a buffer with a view over the source sequence, causing a specified number of enumerators to obtain access to all of the sequence's elements without causing multiple enumerations over the source. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of enumerators that can access the underlying buffer. Once every enumerator has obtained an element from the buffer, the element is removed from the buffer. + /// Buffer enabling a specified number of enumerators to retrieve all elements from the shared source sequence, without duplicating source enumeration side-effects. + public static IBuffer Memoize(this IEnumerable source, int readerCount) + { + if (source == null) + throw new ArgumentNullException("source"); + if (readerCount <= 0) + throw new ArgumentOutOfRangeException("readerCount"); + + return new MemoizedBuffer(source.GetEnumerator(), readerCount); + } + + /// + /// Memoizes the source sequence within a selector function where a specified number of enumerators can get access to all of the sequence's elements without causing multiple enumerations over the source. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Number of enumerators that can access the underlying buffer. Once every enumerator has obtained an element from the buffer, the element is removed from the buffer. + /// Selector function with memoized access to the source sequence for a specified number of enumerators. + /// Sequence resulting from applying the selector function to the memoized view over the source sequence. + public static IEnumerable Memoize(this IEnumerable source, int readerCount, Func, IEnumerable> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (readerCount <= 0) + throw new ArgumentOutOfRangeException("readerCount"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return Create(() => selector(source.Memoize(readerCount)).GetEnumerator()); + } + + class MemoizedBuffer : IBuffer + { + private IEnumerator _source; + private IRefCountList _buffer; + private bool _stopped; + private Exception _error; + private bool _disposed; + + public MemoizedBuffer(IEnumerator source) + : this(source, new MaxRefCountList()) + { + } + + public MemoizedBuffer(IEnumerator source, int readerCount) + : this(source, new RefCountList(readerCount)) + { + } + + private MemoizedBuffer(IEnumerator source, IRefCountList buffer) + { + _source = source; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + if (_disposed) + throw new ObjectDisposedException(""); + + return GetEnumerator_(); + } + + private IEnumerator GetEnumerator_() + { + var i = 0; + + try + { + while (true) + { + if (_disposed) + throw new ObjectDisposedException(""); + + var hasValue = default(bool); + var current = default(T); + + lock (_source) + { + if (i >= _buffer.Count) + { + if (!_stopped) + { + try + { + hasValue = _source.MoveNext(); + if (hasValue) + current = _source.Current; + } + catch (Exception ex) + { + _stopped = true; + _error = ex; + + _source.Dispose(); + } + } + + if (_stopped) + { + if (_error != null) + throw _error; + else + break; + } + + if (hasValue) + { + _buffer.Add(current); + } + } + else + { + hasValue = true; + } + } + + if (hasValue) + yield return _buffer[i]; + else + break; + + i++; + } + } + finally + { + if (_buffer != null) + _buffer.Done(i + 1); + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + if (_disposed) + throw new ObjectDisposedException(""); + + return GetEnumerator(); + } + + public void Dispose() + { + lock (_source) + { + if (!_disposed) + { + _source.Dispose(); + _source = null; + + _buffer.Clear(); + _buffer = null; + } + + _disposed = true; + } + } + } + } + + /// + /// Represents a buffer exposing a shared view over an underlying enumerable sequence. + /// + /// Element type. + public interface IBuffer< +#if !NO_VARIANCE && !SILVERLIGHT4 // SL4 has defined IEnumerable with invariant T + out +#endif + T> : IEnumerable, IDisposable + { + } + + interface IRefCountList + { + void Clear(); + + int Count { get; } + + T this[int i] + { + get; + } + + void Add(T item); + + void Done(int index); + } + + class MaxRefCountList : IRefCountList + { + private IList _list = new List(); + + public void Clear() + { + _list.Clear(); + } + + public int Count + { + get { return _list.Count; } + } + + public T this[int i] + { + get { return _list[i]; } + } + + public void Add(T item) + { + _list.Add(item); + } + + public void Done(int index) + { + } + } + + class RefCountList : IRefCountList + { + private int _readerCount; + private readonly IDictionary _list; + private int _count; + + public RefCountList(int readerCount) + { + _readerCount = readerCount; + _list = new Dictionary(); + } + + public int ReaderCount + { + get + { + return _readerCount; + } + + set + { + _readerCount = value; + } + } + + public void Clear() + { + _list.Clear(); + } + + public int Count + { + get { return _count; } + } + + public T this[int i] + { + get + { + Debug.Assert(i < _count); + + var res = default(RefCount); + if (!_list.TryGetValue(i, out res)) + throw new InvalidOperationException("Element no longer available in the buffer."); + + var val = res.Value; + if (--res.Count == 0) + _list.Remove(i); + + return val; + } + } + + public void Add(T item) + { + _list[_count] = new RefCount { Value = item, Count = _readerCount }; + _count++; + } + + public void Done(int index) + { + for (int i = index; i < _count; i++) + { + var ignore = this[i]; + } + + _readerCount--; + } + + class RefCount + { + public int Count; + public T Value; + } + } +} diff --git a/Ix/System.Interactive/EnumerableEx.Creation.cs b/Ix/System.Interactive/EnumerableEx.Creation.cs new file mode 100644 index 0000000..2ba4f16 --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Creation.cs @@ -0,0 +1,173 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; + +namespace System.Linq +{ + public static partial class EnumerableEx + { + /// + /// Creates an enumerable sequence based on an enumerator factory function. + /// + /// Result sequence element type. + /// Enumerator factory function. + /// Sequence that will invoke the enumerator factory upon a call to GetEnumerator. + public static IEnumerable Create(Func> getEnumerator) + { + if (getEnumerator == null) + throw new ArgumentNullException("getEnumerator"); + + return new AnonymousEnumerable(getEnumerator); + } + + class AnonymousEnumerable : IEnumerable + { + private readonly Func> _getEnumerator; + + public AnonymousEnumerable(Func> getEnumerator) + { + _getEnumerator = getEnumerator; + } + + public IEnumerator GetEnumerator() + { + return _getEnumerator(); + } + + Collections.IEnumerator Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + /// + /// Returns a sequence with a single element. + /// + /// Result sequence element type. + /// Single element of the resulting sequence. + /// Sequence with a single element. + public static IEnumerable Return(TResult value) + { + yield return value; + } + + /// + /// Returns a sequence that throws an exception upon enumeration. + /// + /// Result sequence element type. + /// Exception to throw upon enumerating the resulting sequence. + /// Sequence that throws the specified exception upon enumeration. + public static IEnumerable Throw(Exception exception) + { + if (exception == null) + throw new ArgumentNullException("exception"); + + return Throw_(exception); + } + + private static IEnumerable Throw_(Exception exception) + { + throw exception; +#pragma warning disable 0162 + yield break; +#pragma warning restore 0162 + } + + /// + /// Creates an enumerable sequence based on an enumerable factory function. + /// + /// Result sequence element type. + /// Enumerable factory function. + /// Sequence that will invoke the enumerable factory upon a call to GetEnumerator. + public static IEnumerable Defer(Func> enumerableFactory) + { + if (enumerableFactory == null) + throw new ArgumentNullException("enumerableFactory"); + + return Defer_(enumerableFactory); + } + + private static IEnumerable Defer_(Func> enumerableFactory) + { + foreach (var item in enumerableFactory()) + yield return item; + } + + /// + /// Generates a sequence by mimicking a for loop. + /// + /// State type. + /// Result sequence element type. + /// Initial state of the generator loop. + /// Loop condition. + /// State update function to run after every iteration of the generator loop. + /// Result selector to compute resulting sequence elements. + /// Sequence obtained by running the generator loop, yielding computed elements. + public static IEnumerable Generate(TState initialState, Func condition, Func iterate, Func resultSelector) + { + if (condition == null) + throw new ArgumentNullException("condition"); + if (iterate == null) + throw new ArgumentNullException("iterate"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return Generate_(initialState, condition, iterate, resultSelector); + } + + private static IEnumerable Generate_(TState initialState, Func condition, Func iterate, Func resultSelector) + { + for (var i = initialState; condition(i); i = iterate(i)) + yield return resultSelector(i); + } + + /// + /// Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage duration. + /// + /// Source element type. + /// Resource type. + /// Resource factory function. + /// Enumerable factory function, having access to the obtained resource. + /// Sequence whose use controls the lifetime of the associated obtained resource. + public static IEnumerable Using(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable + { + if (resourceFactory == null) + throw new ArgumentNullException("resourceFactory"); + if (enumerableFactory == null) + throw new ArgumentNullException("enumerableFactory"); + + return Using_(resourceFactory, enumerableFactory); + } + + private static IEnumerable Using_(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable + { + using (var res = resourceFactory()) + foreach (var item in enumerableFactory(res)) + yield return item; + } + + /// + /// Generates a sequence by repeating the given value infinitely. + /// + /// Result sequence element type. + /// Value to repreat in the resulting sequence. + /// Sequence repeating the given value infinitely. + public static IEnumerable Repeat(TResult value) + { + while (true) + yield return value; + } + + /// + /// Generates a sequence that contains one repeated value. + /// + /// Result sequence element type. + /// The value to be repeated. + /// The number of times to repeat the value in the generated sequence. + /// Sequence that contains a repeated value. + public static IEnumerable Repeat(TResult element, int count) + { + return Enumerable.Repeat(element, count); + } + } +} diff --git a/Ix/System.Interactive/EnumerableEx.Exceptions.cs b/Ix/System.Interactive/EnumerableEx.Exceptions.cs new file mode 100644 index 0000000..a3ff330 --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Exceptions.cs @@ -0,0 +1,284 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; + +namespace System.Linq +{ + public static partial class EnumerableEx + { + /// + /// Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error. + /// + /// Source sequence element type. + /// Exception type to catch. + /// Source sequence. + /// Handler to invoke when an exception of the specified type occurs. + /// Source sequence, concatenated with an exception handler result sequence in case of an error. + public static IEnumerable Catch(this IEnumerable source, Func> handler) + where TException : Exception + { + if (source == null) + throw new ArgumentNullException("source"); + if (handler == null) + throw new ArgumentNullException("handler"); + + return source.Catch_(handler); + } + + private static IEnumerable Catch_(this IEnumerable source, Func> handler) + where TException : Exception + { + var err = default(IEnumerable); + + using (var e = source.GetEnumerator()) + { + while (true) + { + var b = default(bool); + var c = default(TSource); + + try + { + b = e.MoveNext(); + c = e.Current; + } + catch (TException ex) + { + err = handler(ex); + break; + } + + if (!b) + break; + + yield return c; + } + } + + if (err != null) + { + foreach (var item in err) + yield return item; + } + } + + /// + /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence that continues to concatenate source sequences while errors occur. + public static IEnumerable Catch(this IEnumerable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Catch_(); + } + + /// + /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence that continues to concatenate source sequences while errors occur. + public static IEnumerable Catch(params IEnumerable[] sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Catch_(); + } + + /// + /// Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error. + /// + /// Source sequence element type. + /// First sequence. + /// Second sequence, concatenated to the result in case the first sequence completes exceptionally. + /// The first sequence, followed by the second sequence in case an error is produced. + public static IEnumerable Catch(this IEnumerable first, IEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return new[] { first, second }.Catch_(); + } + + private static IEnumerable Catch_(this IEnumerable> sources) + { + var error = default(Exception); + + foreach (var source in sources) + { + using (var e = source.GetEnumerator()) + { + error = null; + + while (true) + { + var b = default(bool); + var c = default(TSource); + + try + { + b = e.MoveNext(); + c = e.Current; + } + catch (Exception ex) + { + error = ex; + break; + } + + if (!b) + break; + + yield return c; + } + + if (error == null) + break; + } + } + + if (error != null) + throw error; + } + + /// + /// Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to run upon termination of the sequence, or when an enumerator is disposed. + /// Source sequence with guarantees on the invocation of the finally action. + public static IEnumerable Finally(this IEnumerable source, Action finallyAction) + { + if (source == null) + throw new ArgumentNullException("source"); + if (finallyAction == null) + throw new ArgumentNullException("finallyAction"); + + return source.Finally_(finallyAction); + } + + private static IEnumerable Finally_(this IEnumerable source, Action finallyAction) + { + try + { + foreach (var item in source) + yield return item; + } + finally + { + finallyAction(); + } + } + + /// + /// Creates a sequence that concatenates both given sequences, regardless of whether an error occurs. + /// + /// Source sequence element type. + /// First sequence. + /// Second sequence. + /// Sequence concatenating the elements of both sequences, ignoring errors. + public static IEnumerable OnErrorResumeNext(this IEnumerable first, IEnumerable second) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + + return OnErrorResumeNext_(new[] { first, second }); + } + + /// + /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence concatenating the elements of the given sequences, ignoring errors. + public static IEnumerable OnErrorResumeNext(params IEnumerable[] sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return OnErrorResumeNext_(sources); + } + + /// + /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence concatenating the elements of the given sequences, ignoring errors. + public static IEnumerable OnErrorResumeNext(this IEnumerable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return OnErrorResumeNext_(sources); + } + + private static IEnumerable OnErrorResumeNext_(IEnumerable> sources) + { + foreach (var source in sources) + { + using (var innerEnumerator = source.GetEnumerator()) + { + while (true) + { + var value = default(TSource); + try + { + if (!innerEnumerator.MoveNext()) + break; + value = innerEnumerator.Current; + } + catch + { + break; + } + + yield return value; + } + } + } + } + + /// + /// Creates a sequence that retries enumerating the source sequence as long as an error occurs. + /// + /// Source sequence element type. + /// Source sequence. + /// Sequence concatenating the results of the source sequence as long as an error occurs. + public static IEnumerable Retry(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return new[] { source }.Repeat().Catch(); + } + + /// + /// Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified maximum number of retries. + /// + /// Source sequence element type. + /// Source sequence. + /// Maximum number of retries. + /// Sequence concatenating the results of the source sequence as long as an error occurs. + public static IEnumerable Retry(this IEnumerable source, int retryCount) + { + if (source == null) + throw new ArgumentNullException("source"); + if (retryCount < 0) + throw new ArgumentOutOfRangeException("retryCount"); + + return new[] { source }.Repeat(retryCount).Catch(); + } + } +} diff --git a/Ix/System.Interactive/EnumerableEx.Imperative.cs b/Ix/System.Interactive/EnumerableEx.Imperative.cs new file mode 100644 index 0000000..fff3927 --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Imperative.cs @@ -0,0 +1,156 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + +namespace System.Linq +{ + public static partial class EnumerableEx + { + /// + /// Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. + /// + /// Result sequence element type. + /// Loop condition. + /// Sequence to repeat while the condition evaluates true. + /// Sequence generated by repeating the given sequence while the condition evaluates to true. + public static IEnumerable While(Func condition, IEnumerable source) + { + if (condition == null) + throw new ArgumentNullException("condition"); + if (source == null) + throw new ArgumentNullException("source"); + + return WhileCore(condition, source).Concat(); + } + + static IEnumerable> WhileCore(Func condition, IEnumerable source) + { + while (condition()) + yield return source; + } + + /// + /// Returns an enumerable sequence based on the evaluation result of the given condition. + /// + /// Result sequence element type. + /// Condition to evaluate. + /// Sequence to return in case the condition evaluates true. + /// Sequence to return in case the condition evaluates false. + /// Either of the two input sequences based on the result of evaluating the condition. + public static IEnumerable If(Func condition, IEnumerable thenSource, IEnumerable elseSource) + { + if (condition == null) + throw new ArgumentNullException("condition"); + if (thenSource == null) + throw new ArgumentNullException("thenSource"); + if (elseSource == null) + throw new ArgumentNullException("elseSource"); + + return EnumerableEx.Defer(() => condition() ? thenSource : elseSource); + } + + /// + /// Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. + /// + /// Result sequence element type. + /// Condition to evaluate. + /// Sequence to return in case the condition evaluates true. + /// The given input sequence if the condition evaluates true; otherwise, an empty sequence. + public static IEnumerable If(Func condition, IEnumerable thenSource) + { + if (condition == null) + throw new ArgumentNullException("condition"); + if (thenSource == null) + throw new ArgumentNullException("thenSource"); + + return EnumerableEx.Defer(() => condition() ? thenSource : Enumerable.Empty()); + } + + /// + /// Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. + /// + /// Result sequence element type. + /// Source sequence to repeat while the condition evaluates true. + /// Loop condition. + /// Sequence generated by repeating the given sequence until the condition evaluates to false. + public static IEnumerable DoWhile(this IEnumerable source, Func condition) + { + if (source == null) + throw new ArgumentNullException("source"); + if (condition == null) + throw new ArgumentNullException("condition"); + + return source.Concat(While(condition, source)); + } + + /// + /// Returns a sequence from a dictionary based on the result of evaluating a selector function. + /// + /// Type of the selector value. + /// Result sequence element type. + /// Selector function used to pick a sequence from the given sources. + /// Dictionary mapping selector values onto resulting sequences. + /// The source sequence corresponding with the evaluated selector value; otherwise, an empty sequence. + public static IEnumerable Case(Func selector, IDictionary> sources) + { + if (selector == null) + throw new ArgumentNullException("selector"); + if (sources == null) + throw new ArgumentNullException("sources"); + + return Case(selector, sources, Enumerable.Empty()); + } + + /// + /// Returns a sequence from a dictionary based on the result of evaluating a selector function, also specifying a default sequence. + /// + /// Type of the selector value. + /// Result sequence element type. + /// Selector function used to pick a sequence from the given sources. + /// Dictionary mapping selector values onto resulting sequences. + /// Default sequence to return in case there's no corresponding source for the computed selector value. + /// The source sequence corresponding with the evaluated selector value; otherwise, the default source. + public static IEnumerable Case(Func selector, IDictionary> sources, IEnumerable defaultSource) + { + if (selector == null) + throw new ArgumentNullException("selector"); + if (sources == null) + throw new ArgumentNullException("sources"); + if (defaultSource == null) + throw new ArgumentNullException("defaultSource"); + + return EnumerableEx.Defer(() => + { + IEnumerable result; + if (!sources.TryGetValue(selector(), out result)) + result = defaultSource; + return result; + }); + } + + /// + /// Generates a sequence by enumerating a source sequence, mapping its elements on result sequences, and concatenating those sequences. + /// + /// Source sequence element type. + /// Result sequence element type. + /// Source sequence. + /// Result selector to evaluate for each iteration over the source. + /// Sequence concatenating the inner sequences that result from evaluating the result selector on elements from the source. + public static IEnumerable For(IEnumerable source, Func> resultSelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return ForCore(source, resultSelector).Concat(); + } + + static IEnumerable> ForCore(IEnumerable source, Func> resultSelector) + { + return source.Select(resultSelector); + } + } +} diff --git a/Ix/System.Interactive/EnumerableEx.Multiple.cs b/Ix/System.Interactive/EnumerableEx.Multiple.cs new file mode 100644 index 0000000..ffba503 --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Multiple.cs @@ -0,0 +1,96 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + +namespace System.Linq +{ + public static partial class EnumerableEx + { + /// + /// Concatenates the input sequences. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence with the elements of the source sequences concatenated. + public static IEnumerable Concat(this IEnumerable> sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Concat_(); + } + + /// + /// Concatenates the input sequences. + /// + /// Source sequence element type. + /// Source sequences. + /// Sequence with the elements of the source sequences concatenated. + public static IEnumerable Concat(params IEnumerable[] sources) + { + if (sources == null) + throw new ArgumentNullException("sources"); + + return sources.Concat_(); + } + + private static IEnumerable Concat_(this IEnumerable> sources) + { + foreach (var source in sources) + foreach (var item in source) + yield return item; + } + + /// + /// Projects each element of a sequence to an given sequence and flattens the resulting sequences into one sequence. + /// + /// First source sequence element type. + /// Second source sequence element type. + /// A sequence of values to project. + /// Inner sequence each source sequenec element is projected onto. + /// Sequence flattening the sequences that result from projecting elements in the source sequence. + public static IEnumerable SelectMany(this IEnumerable source, IEnumerable other) + { + if (source == null) + throw new ArgumentNullException("source"); + if (other == null) + throw new ArgumentNullException("other"); + + return source.SelectMany(_ => other); + } + +#if NO_ZIP + /// + /// Merges two sequences by applying the specified selector function on index-based corresponding element pairs from both sequences. + /// + /// The type of the elements of the first input sequence. + /// The type of the elements of the second input sequence. + /// The type of the elements of the result sequence. + /// The first sequence to merge. + /// The second sequence to merge. + /// Function to apply to each pair of elements from both sequences. + /// Sequence consisting of the result of pairwise application of the selector function over pairs of elements from the source sequences. + public static IEnumerable Zip(this IEnumerable first, IEnumerable second, Func resultSelector) + { + if (first == null) + throw new ArgumentNullException("first"); + if (second == null) + throw new ArgumentNullException("second"); + if (resultSelector == null) + throw new ArgumentNullException("resultSelector"); + + return Zip_(first, second, resultSelector); + } + + private static IEnumerable Zip_(this IEnumerable first, IEnumerable second, Func resultSelector) + { + using (var e1 = first.GetEnumerator()) + using (var e2 = second.GetEnumerator()) + while (e1.MoveNext() && e2.MoveNext()) + yield return resultSelector(e1.Current, e2.Current); + } +#endif + } +} diff --git a/Ix/System.Interactive/EnumerableEx.Single.cs b/Ix/System.Interactive/EnumerableEx.Single.cs new file mode 100644 index 0000000..6151ea9 --- /dev/null +++ b/Ix/System.Interactive/EnumerableEx.Single.cs @@ -0,0 +1,672 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + +namespace System.Linq +{ + public static partial class EnumerableEx + { + /// + /// Hides the enumerable sequence object identity. + /// + /// Source sequence element type. + /// Source sequence. + /// Enumerable sequence with the same behavior as the original, but hiding the source object identity. + /// AsEnumerable doesn't hide the object identity, and simply acts as a cast to the IEnumerable<TSource> interface. + public static IEnumerable Hide(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.Hide_(); + } + + private static IEnumerable Hide_(this IEnumerable source) + { + foreach (var item in source) + yield return item; + } + + /// + /// Enumerates the sequence and invokes the given action for each value in the sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + public static void ForEach(this IEnumerable source, Action onNext) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + + foreach (var item in source) + onNext(item); + } + + /// + /// Enumerates the sequence and invokes the given action for each value in the sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + public static void ForEach(this IEnumerable source, Action onNext) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + + var i = 0; + foreach (var item in source) + onNext(item, i++); + } + + /// + /// Lazily invokes an action for each value in the sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IEnumerable Do(this IEnumerable source, Action onNext) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + + return DoHelper(source, onNext, _ => { }, () => { }); + } + + /// + /// Lazily invokes an action for each value in the sequence, and executes an action for successful termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Action to invoke on successful termination of the sequence. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IEnumerable Do(this IEnumerable source, Action onNext, Action onCompleted) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onCompleted == null) + throw new ArgumentNullException("onCompleted"); + + return DoHelper(source, onNext, _ => { }, onCompleted); + } + + /// + /// Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Action to invoke on exceptional termination of the sequence. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IEnumerable Do(this IEnumerable source, Action onNext, Action onError) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onError == null) + throw new ArgumentNullException("onError"); + + return DoHelper(source, onNext, onError, () => { }); + } + + /// + /// Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Action to invoke for each element. + /// Action to invoke on exceptional termination of the sequence. + /// Action to invoke on successful termination of the sequence. + /// Sequence exhibiting the specified side-effects upon enumeration. + public static IEnumerable Do(this IEnumerable source, Action onNext, Action onError, Action onCompleted) + { + if (source == null) + throw new ArgumentNullException("source"); + if (onNext == null) + throw new ArgumentNullException("onNext"); + if (onError == null) + throw new ArgumentNullException("onError"); + if (onCompleted == null) + throw new ArgumentNullException("onCompleted"); + + return DoHelper(source, onNext, onError, onCompleted); + } + +#if !NO_RXINTERFACES + /// + /// Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination. + /// + /// Source sequence element type. + /// Source sequence. + /// Observer to invoke notification calls on. + /// Sequence exhibiting the side-effects of observer method invocation upon enumeration. + public static IEnumerable Do(this IEnumerable source, IObserver observer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (observer == null) + throw new ArgumentNullException("observer"); + + return DoHelper(source, observer.OnNext, observer.OnError, observer.OnCompleted); + } +#endif + + private static IEnumerable DoHelper(this IEnumerable source, Action onNext, Action onError, Action onCompleted) + { + using (var e = source.GetEnumerator()) + { + while (true) + { + var current = default(TSource); + try + { + if (!e.MoveNext()) + break; + + current = e.Current; + } + catch (Exception ex) + { + onError(ex); + throw; + } + + onNext(current); + yield return current; + } + + onCompleted(); + } + } + + /// + /// Generates a sequence of non-overlapping adjacent buffers over the source sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of elements for allocated buffers. + /// Sequence of buffers containing source sequence elements. + public static IEnumerable> Buffer(this IEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count <= 0) + throw new ArgumentOutOfRangeException("count"); + + return source.Buffer_(count, count); + } + + /// + /// Generates a sequence of buffers over the source sequence, with specified length and possible overlap. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of elements for allocated buffers. + /// Number of elements to skip between the start of consecutive buffers. + /// Sequence of buffers containing source sequence elements. + public static IEnumerable> Buffer(this IEnumerable source, int count, int skip) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count <= 0) + throw new ArgumentOutOfRangeException("count"); + if (skip <= 0) + throw new ArgumentOutOfRangeException("skip"); + + return source.Buffer_(count, skip); + } + + private static IEnumerable> Buffer_(this IEnumerable source, int count, int skip) + { + var buffers = new Queue>(); + + var i = 0; + foreach (var item in source) + { + if (i % skip == 0) + buffers.Enqueue(new List(count)); + + foreach (var buffer in buffers) + buffer.Add(item); + + if (buffers.Count > 0 && buffers.Peek().Count == count) + yield return buffers.Dequeue(); + + i++; + } + + while (buffers.Count > 0) + yield return buffers.Dequeue(); + } + + /// + /// Ignores all elements in the source sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// Source sequence without its elements. + public static IEnumerable IgnoreElements(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.IgnoreElements_(); + } + + private static IEnumerable IgnoreElements_(this IEnumerable source) + { + foreach (var item in source) + ; + + yield break; + } + + /// + /// Returns elements with a distinct key value by using the default equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Sequence that contains the elements from the source sequence with distinct key values. + public static IEnumerable Distinct(this IEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.Distinct_(keySelector, EqualityComparer.Default); + } + + /// + /// Returns elements with a distinct key value by using the specified equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Comparer used to compare key values. + /// Sequence that contains the elements from the source sequence with distinct key values. + public static IEnumerable Distinct(this IEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.Distinct_(keySelector, comparer); + } + + private static IEnumerable Distinct_(this IEnumerable source, Func keySelector, IEqualityComparer comparer) + { + var set = new HashSet(comparer); + + foreach (var item in source) + { + var key = keySelector(item); + if (set.Add(key)) + yield return item; + } + } + +#if NO_HASHSET + class HashSet + { + private Dictionary _set; + + public HashSet(IEqualityComparer comparer) + { + _set = new Dictionary(comparer); + } + + public bool Add(T value) + { + if (_set.ContainsKey(value)) + return false; + + _set[value] = null; + return true; + } + } +#endif + + /// + /// Returns consecutive distinct elements by using the default equality comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Sequence without adjacent non-distinct elements. + public static IEnumerable DistinctUntilChanged(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.DistinctUntilChanged_(x => x, EqualityComparer.Default); + } + + /// + /// Returns consecutive distinct elements by using the specified equality comparer to compare values. + /// + /// Source sequence element type. + /// Source sequence. + /// Comparer used to compare values. + /// Sequence without adjacent non-distinct elements. + public static IEnumerable DistinctUntilChanged(this IEnumerable source, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.DistinctUntilChanged_(x => x, comparer); + } + + /// + /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Sequence without adjacent non-distinct elements. + public static IEnumerable DistinctUntilChanged(this IEnumerable source, Func keySelector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + + return source.DistinctUntilChanged_(keySelector, EqualityComparer.Default); + } + + /// + /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. + /// + /// Source sequence element type. + /// Key type. + /// Source sequence. + /// Key selector. + /// Comparer used to compare key values. + /// Sequence without adjacent non-distinct elements. + public static IEnumerable DistinctUntilChanged(this IEnumerable source, Func keySelector, IEqualityComparer comparer) + { + if (source == null) + throw new ArgumentNullException("source"); + if (keySelector == null) + throw new ArgumentNullException("keySelector"); + if (comparer == null) + throw new ArgumentNullException("comparer"); + + return source.DistinctUntilChanged_(keySelector, comparer); + } + + private static IEnumerable DistinctUntilChanged_(this IEnumerable source, Func keySelector, IEqualityComparer comparer) + { + var currentKey = default(TKey); + var hasCurrentKey = false; + + foreach (var item in source) + { + var key = keySelector(item); + + var comparerEquals = false; + if (hasCurrentKey) + { + comparerEquals = comparer.Equals(currentKey, key); + } + + if (!hasCurrentKey || !comparerEquals) + { + hasCurrentKey = true; + currentKey = key; + yield return item; + } + } + } + + /// + /// Expands the sequence by recursively applying a selector function. + /// + /// Source sequence element type. + /// Source sequence. + /// Selector function to retrieve the next sequence to expand. + /// Sequence with results from the recursive expansion of the source sequence. + public static IEnumerable Expand(this IEnumerable source, Func> selector) + { + if (source == null) + throw new ArgumentNullException("source"); + if (selector == null) + throw new ArgumentNullException("selector"); + + return source.Expand_(selector); + } + + private static IEnumerable Expand_(this IEnumerable source, Func> selector) + { + var queue = new Queue>(); + queue.Enqueue(source); + + while (queue.Count > 0) + { + var src = queue.Dequeue(); + + foreach (var item in src) + { + queue.Enqueue(selector(item)); + yield return item; + } + } + } + + /// + /// Returns the source sequence prefixed with the specified value. + /// + /// Source sequence element type. + /// Source sequence. + /// Values to prefix the sequence with. + /// Sequence starting with the specified prefix value, followed by the source sequence. + public static IEnumerable StartWith(this IEnumerable source, params TSource[] values) + { + if (source == null) + throw new ArgumentNullException("source"); + + return source.StartWith_(values); + } + + private static IEnumerable StartWith_(this IEnumerable source, params TSource[] values) + { + foreach (var x in values) + yield return x; + + foreach (var item in source) + yield return item; + } + + /// + /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. + /// + /// Source sequence element type. + /// Accumulation type. + /// Source sequence. + /// Accumulator seed value. + /// Accumulation function to apply to the current accumulation value and each element of the sequence. + /// Sequence with all intermediate accumulation values resulting from scanning the sequence. + public static IEnumerable Scan(this IEnumerable source, TAccumulate seed, Func accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return source.Scan_(seed, accumulator); + } + + private static IEnumerable Scan_(this IEnumerable source, TAccumulate seed, Func accumulator) + { + var acc = seed; + + foreach (var item in source) + { + acc = accumulator(acc, item); + yield return acc; + } + } + + /// + /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. + /// + /// Source sequence element type. + /// Source sequence. + /// Accumulation function to apply to the current accumulation value and each element of the sequence. + /// Sequence with all intermediate accumulation values resulting from scanning the sequence. + public static IEnumerable Scan(this IEnumerable source, Func accumulator) + { + if (source == null) + throw new ArgumentNullException("source"); + if (accumulator == null) + throw new ArgumentNullException("accumulator"); + + return source.Scan_(accumulator); + } + + private static IEnumerable Scan_(this IEnumerable source, Func accumulator) + { + var hasSeed = false; + var acc = default(TSource); + + foreach (var item in source) + { + if (!hasSeed) + { + hasSeed = true; + acc = item; + continue; + } + + acc = accumulator(acc, item); + yield return acc; + } + } + + /// + /// Returns a specified number of contiguous elements from the end of the sequence. + /// + /// Source sequence element type. + /// Source sequence. + /// The number of elements to take from the end of the sequence. + /// Sequence with the specified number of elements counting from the end of the source sequence. + public static IEnumerable TakeLast(this IEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return source.TakeLast_(count); + } + + private static IEnumerable TakeLast_(this IEnumerable source, int count) + { + var q = new Queue(count); + + foreach (var item in source) + { + if (q.Count >= count) + q.Dequeue(); + q.Enqueue(item); + } + + while (q.Count > 0) + yield return q.Dequeue(); + } + + /// + /// Bypasses a specified number of contiguous elements from the end of the sequence and returns the remaining elements. + /// + /// Source sequence element type. + /// Source sequence. + /// The number of elements to skip from the end of the sequence before returning the remaining elements. + /// Sequence bypassing the specified number of elements counting from the end of the source sequence. + public static IEnumerable SkipLast(this IEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return source.SkipLast_(count); + } + + private static IEnumerable SkipLast_(this IEnumerable source, int count) + { + var q = new Queue(); + + foreach (var x in source) + { + q.Enqueue(x); + if (q.Count > count) + yield return q.Dequeue(); + } + } + + /// + /// Repeats and concatenates the source sequence infinitely. + /// + /// Source sequence element type. + /// Source sequence. + /// Sequence obtained by concatenating the source sequence to itself infinitely. + public static IEnumerable Repeat(this IEnumerable source) + { + if (source == null) + throw new ArgumentNullException("source"); + + return Repeat_(source); + } + + private static IEnumerable Repeat_(IEnumerable source) + { + while (true) + foreach (var item in source) + yield return item; + } + + /// + /// Repeats and concatenates the source sequence the given number of times. + /// + /// Source sequence element type. + /// Source sequence. + /// Number of times to repeat the source sequence. + /// Sequence obtained by concatenating the source sequence to itself the specified number of times. + public static IEnumerable Repeat(this IEnumerable source, int count) + { + if (source == null) + throw new ArgumentNullException("source"); + if (count < 0) + throw new ArgumentOutOfRangeException("count"); + + return Repeat_(source, count); + } + + private static IEnumerable Repeat_(IEnumerable source, int count) + { + for (var i = 0; i < count; i++) + foreach (var item in source) + yield return item; + } + } +} diff --git a/Ix/System.Interactive/Properties/AssemblyInfo.cs b/Ix/System.Interactive/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0bafb78 --- /dev/null +++ b/Ix/System.Interactive/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +using System; +using System.Reflection; +using System.Resources; +using System.Runtime.InteropServices; +using System.Security; + +[assembly: AssemblyTitle("System.Interactive")] +// Notice: same description as in the .nuspec files; see Source/Interactive Extensions/Setup/NuGet +[assembly: AssemblyDescription("Interactive Extensions Main Library used to express queries over enumerable sequences.")] +#if DEBUG +[assembly: AssemblyConfiguration("Debug")] +#else +[assembly: AssemblyConfiguration("Retail")] +#endif +[assembly: AssemblyCompany("Microsoft Corporation")] +#if STABLE +[assembly: AssemblyProduct("Interactive Extensions")] +#else +[assembly: AssemblyProduct("Interactive Extensions (Experimental Release)")] +#endif +[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")] +[assembly: NeutralResourcesLanguage("en-US")] + +#if !PLIB +[assembly: ComVisible(false)] +#endif + +[assembly: CLSCompliant(true)] + +#if DESKTOPCLR && NO_CODECOVERAGE +[assembly: AllowPartiallyTrustedCallers] +#endif + +// +// Note: Assembly (file) version numbers get inserted by the build system on the fly. Inspect the Team Build workflows +// and the custom activity in Build/Source/Activities/AppendVersionInfo.cs for more information. +// diff --git a/Ix/System.Interactive/System.Interactive.csproj b/Ix/System.Interactive/System.Interactive.csproj new file mode 100644 index 0000000..a4646a5 --- /dev/null +++ b/Ix/System.Interactive/System.Interactive.csproj @@ -0,0 +1,41 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {8E4B04F0-915E-48F9-9796-76278C6094BD} + Library + Properties + System.Interactive + System.Interactive + v4.0 + 512 + true + + + + $(OutputPath)\$(AssemblyName).XML + + + Profile1 + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Ix/Tests/App.cs b/Ix/Tests/App.cs new file mode 100644 index 0000000..3f27e96 --- /dev/null +++ b/Ix/Tests/App.cs @@ -0,0 +1,47 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if SILVERLIGHT && !SILVERLIGHTM7 +using System; +using System.Diagnostics; +using System.Windows; +using System.Windows.Browser; +using Microsoft.Silverlight.Testing; + +namespace InteractiveTests +{ + public class App : Application + { + public App() + { + this.Startup += (o, e) => + { + // TODO: Investigate UnitTestSettings configuration of TestService and LogProviders. + // var settings = new UnitTestSettings { StartRunImmediately = true }; + RootVisual = UnitTestSystem.CreateTestPage(/* settings */); + }; + + this.UnhandledException += (o, e) => + { + if (!Debugger.IsAttached) + { + e.Handled = true; + Deployment.Current.Dispatcher.BeginInvoke(delegate { ReportErrorToDOM(e); }); + } + }; + } + + private void ReportErrorToDOM(ApplicationUnhandledExceptionEventArgs e) + { + try + { + string errorMsg = e.ExceptionObject.Message + e.ExceptionObject.StackTrace; + errorMsg = errorMsg.Replace('"', '\'').Replace("\r\n", @"\n"); + + HtmlPage.Window.Eval("throw new Error(\"Unhandled Error in Silverlight Application " + errorMsg + "\");"); + } + catch (Exception) + { + } + } + } +} +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Aggregates.cs b/Ix/Tests/AsyncTests.Aggregates.cs new file mode 100644 index 0000000..1e43178 --- /dev/null +++ b/Ix/Tests/AsyncTests.Aggregates.cs @@ -0,0 +1,2168 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Collections; +using System.Threading; + +namespace Tests +{ + public partial class AsyncTests + { + [TestMethod] + public void Aggregate_Null() + { + AssertThrows(() => AsyncEnumerable.Aggregate(null, (x, y) => x + y)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null)); + + AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y, z => z)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null, z => z)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null)); + + AssertThrows(() => AsyncEnumerable.Aggregate(null, (x, y) => x + y, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y, z => z, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null, z => z, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null, CancellationToken.None)); + } + + [TestMethod] + public void Aggregate1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate((x, y) => x * y); + Assert.AreEqual(ys.Result, 24); + } + + [TestMethod] + public void Aggregate2() + { + var xs = new int[0].ToAsyncEnumerable(); + var ys = xs.Aggregate((x, y) => x * y); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Aggregate3() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Aggregate((x, y) => x * y); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Aggregate4() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate((x, y) => { throw ex; }); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Aggregate5() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => x * y); + Assert.AreEqual(ys.Result, 24); + } + + [TestMethod] + public void Aggregate6() + { + var xs = new int[0].ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => x * y); + Assert.AreEqual(ys.Result, 1); + } + + [TestMethod] + public void Aggregate7() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Aggregate(1, (x, y) => x * y); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Aggregate8() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => { throw ex; }); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Aggregate9() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1); + Assert.AreEqual(ys.Result, 25); + } + + [TestMethod] + public void Aggregate10() + { + var xs = new int[0].ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1); + Assert.AreEqual(ys.Result, 2); + } + + [TestMethod] + public void Aggregate11() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Aggregate12() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => { throw ex; }, x => x + 1); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Aggregate13() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Aggregate(1, (x, y) => x * y, x => { throw ex; }); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Count_Null() + { + AssertThrows(() => AsyncEnumerable.Count(null)); + AssertThrows(() => AsyncEnumerable.Count(null, x => true)); + AssertThrows(() => AsyncEnumerable.Count(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Count(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Count(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Count(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void Count1() + { + Assert.AreEqual(new int[0].ToAsyncEnumerable().Count().Result, 0); + Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count().Result, 3); + AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).Count().Wait()); + } + + [TestMethod] + public void Count2() + { + Assert.AreEqual(new int[0].ToAsyncEnumerable().Count(x => x < 3).Result, 0); + Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => x < 3).Result, 2); + AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).Count(x => x < 3).Wait()); + } + + [TestMethod] + public void Count3() + { + var ex = new Exception("Bang!"); + var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => { throw ex; }); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void LongCount_Null() + { + AssertThrows(() => AsyncEnumerable.LongCount(null)); + AssertThrows(() => AsyncEnumerable.LongCount(null, x => true)); + AssertThrows(() => AsyncEnumerable.LongCount(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.LongCount(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.LongCount(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.LongCount(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void LongCount1() + { + Assert.AreEqual(new int[0].ToAsyncEnumerable().LongCount().Result, 0); + Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount().Result, 3); + AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).LongCount().Wait()); + } + + [TestMethod] + public void LongCount2() + { + Assert.AreEqual(new int[0].ToAsyncEnumerable().LongCount(x => x < 3).Result, 0); + Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => x < 3).Result, 2); + AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).LongCount(x => x < 3).Wait()); + } + + [TestMethod] + public void LongCount3() + { + var ex = new Exception("Bang!"); + var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => { throw ex; }); + AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void All_Null() + { + AssertThrows(() => AsyncEnumerable.All(null, x => true)); + AssertThrows(() => AsyncEnumerable.All(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.All(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.All(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void All1() + { + var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void All2() + { + var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void All3() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).All(x => x % 2 == 0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void All4() + { + var ex = new Exception("Bang!"); + var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => { throw ex; }); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Any_Null() + { + AssertThrows(() => AsyncEnumerable.Any(null)); + AssertThrows(() => AsyncEnumerable.Any(null, x => true)); + AssertThrows(() => AsyncEnumerable.Any(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Any(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Any(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Any(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void Any1() + { + var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any(x => x % 2 == 0); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void Any2() + { + var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => x % 2 != 0); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void Any3() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).Any(x => x % 2 == 0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Any4() + { + var ex = new Exception("Bang!"); + var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => { throw ex; }); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Any5() + { + var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any(); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void Any6() + { + var res = new int[0].ToAsyncEnumerable().Any(); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void Contains_Null() + { + AssertThrows(() => AsyncEnumerable.Contains(null, 42)); + AssertThrows(() => AsyncEnumerable.Contains(null, 42, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Contains(AsyncEnumerable.Return(42), 42, null)); + + AssertThrows(() => AsyncEnumerable.Contains(null, 42, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Contains(null, 42, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Contains(AsyncEnumerable.Return(42), 42, null, CancellationToken.None)); + } + + [TestMethod] + public void Contains1() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); + var ys = xs.Contains(3); + Assert.IsTrue(ys.Result); + } + + [TestMethod] + public void Contains2() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); + var ys = xs.Contains(6); + Assert.IsFalse(ys.Result); + } + + [TestMethod] + public void Contains3() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); + var ys = xs.Contains(-3, new Eq()); + Assert.IsTrue(ys.Result); + } + + [TestMethod] + public void Contains4() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); + var ys = xs.Contains(-6, new Eq()); + Assert.IsFalse(ys.Result); + } + + class Eq : IEqualityComparer + { + public bool Equals(int x, int y) + { + return EqualityComparer.Default.Equals(Math.Abs(x), Math.Abs(y)); + } + + public int GetHashCode(int obj) + { + return EqualityComparer.Default.GetHashCode(Math.Abs(obj)); + } + } + + [TestMethod] + public void First_Null() + { + AssertThrows(() => AsyncEnumerable.First(null)); + AssertThrows(() => AsyncEnumerable.First(null, x => true)); + AssertThrows(() => AsyncEnumerable.First(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.First(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.First(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.First(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void First1() + { + var res = AsyncEnumerable.Empty().First(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void First2() + { + var res = AsyncEnumerable.Empty().First(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void First3() + { + var res = AsyncEnumerable.Return(42).First(x => x % 2 != 0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void First4() + { + var res = AsyncEnumerable.Return(42).First(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void First5() + { + var res = AsyncEnumerable.Return(42).First(x => x % 2 == 0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void First6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).First(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void First7() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).First(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void First8() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void First9() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First(x => x % 2 != 0); + Assert.AreEqual(45, res.Result); + } + + [TestMethod] + public void FirstOrDefault_Null() + { + AssertThrows(() => AsyncEnumerable.FirstOrDefault(null)); + AssertThrows(() => AsyncEnumerable.FirstOrDefault(null, x => true)); + AssertThrows(() => AsyncEnumerable.FirstOrDefault(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.FirstOrDefault(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.FirstOrDefault(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.FirstOrDefault(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void FirstOrDefault1() + { + var res = AsyncEnumerable.Empty().FirstOrDefault(); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void FirstOrDefault2() + { + var res = AsyncEnumerable.Empty().FirstOrDefault(x => true); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void FirstOrDefault3() + { + var res = AsyncEnumerable.Return(42).FirstOrDefault(x => x % 2 != 0); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void FirstOrDefault4() + { + var res = AsyncEnumerable.Return(42).FirstOrDefault(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void FirstOrDefault5() + { + var res = AsyncEnumerable.Return(42).FirstOrDefault(x => x % 2 == 0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void FirstOrDefault6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).FirstOrDefault(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void FirstOrDefault7() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).FirstOrDefault(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void FirstOrDefault8() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void FirstOrDefault9() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x % 2 != 0); + Assert.AreEqual(45, res.Result); + } + + [TestMethod] + public void FirstOrDefault10() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x < 10); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void Last_Null() + { + AssertThrows(() => AsyncEnumerable.Last(null)); + AssertThrows(() => AsyncEnumerable.Last(null, x => true)); + AssertThrows(() => AsyncEnumerable.Last(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Last(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Last(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Last(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void Last1() + { + var res = AsyncEnumerable.Empty().Last(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Last2() + { + var res = AsyncEnumerable.Empty().Last(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Last3() + { + var res = AsyncEnumerable.Return(42).Last(x => x % 2 != 0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Last4() + { + var res = AsyncEnumerable.Return(42).Last(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void Last5() + { + var res = AsyncEnumerable.Return(42).Last(x => x % 2 == 0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void Last6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).Last(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Last7() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).Last(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Last8() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Last(); + Assert.AreEqual(90, res.Result); + } + + [TestMethod] + public void Last9() + { + var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Last(x => x % 2 != 0); + Assert.AreEqual(45, res.Result); + } + + [TestMethod] + public void LastOrDefault_Null() + { + AssertThrows(() => AsyncEnumerable.LastOrDefault(null)); + AssertThrows(() => AsyncEnumerable.LastOrDefault(null, x => true)); + AssertThrows(() => AsyncEnumerable.LastOrDefault(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.LastOrDefault(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.LastOrDefault(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.LastOrDefault(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void LastOrDefault1() + { + var res = AsyncEnumerable.Empty().LastOrDefault(); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void LastOrDefault2() + { + var res = AsyncEnumerable.Empty().LastOrDefault(x => true); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void LastOrDefault3() + { + var res = AsyncEnumerable.Return(42).LastOrDefault(x => x % 2 != 0); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void LastOrDefault4() + { + var res = AsyncEnumerable.Return(42).LastOrDefault(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void LastOrDefault5() + { + var res = AsyncEnumerable.Return(42).LastOrDefault(x => x % 2 == 0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void LastOrDefault6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).LastOrDefault(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void LastOrDefault7() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).LastOrDefault(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void LastOrDefault8() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault(); + Assert.AreEqual(90, res.Result); + } + + [TestMethod] + public void LastOrDefault9() + { + var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x % 2 != 0); + Assert.AreEqual(45, res.Result); + } + + [TestMethod] + public void LastOrDefault10() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x < 10); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void Single_Null() + { + AssertThrows(() => AsyncEnumerable.Single(null)); + AssertThrows(() => AsyncEnumerable.Single(null, x => true)); + AssertThrows(() => AsyncEnumerable.Single(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Single(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Single(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Single(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void Single1() + { + var res = AsyncEnumerable.Empty().Single(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Single2() + { + var res = AsyncEnumerable.Empty().Single(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Single3() + { + var res = AsyncEnumerable.Return(42).Single(x => x % 2 != 0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Single4() + { + var res = AsyncEnumerable.Return(42).Single(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void Single5() + { + var res = AsyncEnumerable.Return(42).Single(x => x % 2 == 0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void Single6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).Single(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Single7() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).Single(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Single8() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Single9() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0); + Assert.AreEqual(45, res.Result); + } + + [TestMethod] + public void Single10() + { + var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void SingleOrDefault_Null() + { + AssertThrows(() => AsyncEnumerable.SingleOrDefault(null)); + AssertThrows(() => AsyncEnumerable.SingleOrDefault(null, x => true)); + AssertThrows(() => AsyncEnumerable.SingleOrDefault(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.SingleOrDefault(null, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.SingleOrDefault(null, x => true, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.SingleOrDefault(AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void SingleOrDefault1() + { + var res = AsyncEnumerable.Empty().SingleOrDefault(); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void SingleOrDefault2() + { + var res = AsyncEnumerable.Empty().SingleOrDefault(x => true); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void SingleOrDefault3() + { + var res = AsyncEnumerable.Return(42).SingleOrDefault(x => x % 2 != 0); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void SingleOrDefault4() + { + var res = AsyncEnumerable.Return(42).SingleOrDefault(); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void SingleOrDefault5() + { + var res = AsyncEnumerable.Return(42).SingleOrDefault(x => x % 2 == 0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void SingleOrDefault6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).SingleOrDefault(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SingleOrDefault7() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).SingleOrDefault(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SingleOrDefault8() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void SingleOrDefault9() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x % 2 != 0); + Assert.AreEqual(45, res.Result); + } + + [TestMethod] + public void SingleOrDefault10() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x < 10); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void SingleOrDefault11() + { + var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => true); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void ElementAt_Null() + { + AssertThrows(() => AsyncEnumerable.ElementAt(null, 0)); + AssertThrows(() => AsyncEnumerable.ElementAt(AsyncEnumerable.Return(42), -1)); + + AssertThrows(() => AsyncEnumerable.ElementAt(null, 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ElementAt(AsyncEnumerable.Return(42), -1, CancellationToken.None)); + } + + [TestMethod] + public void ElementAt1() + { + var res = AsyncEnumerable.Empty().ElementAt(0); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException); + } + + [TestMethod] + public void ElementAt2() + { + var res = AsyncEnumerable.Return(42).ElementAt(0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void ElementAt3() + { + var res = AsyncEnumerable.Return(42).ElementAt(1); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException); + } + + [TestMethod] + public void ElementAt4() + { + var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(1); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void ElementAt5() + { + var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(7); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException); + } + + [TestMethod] + public void ElementAt6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).ElementAt(15); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ElementAtOrDefault_Null() + { + AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(null, 0)); + AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(AsyncEnumerable.Return(42), -1)); + + AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(null, 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(AsyncEnumerable.Return(42), -1, CancellationToken.None)); + } + + [TestMethod] + public void ElementAtOrDefault1() + { + var res = AsyncEnumerable.Empty().ElementAtOrDefault(0); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void ElementAtOrDefault2() + { + var res = AsyncEnumerable.Return(42).ElementAtOrDefault(0); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void ElementAtOrDefault3() + { + var res = AsyncEnumerable.Return(42).ElementAtOrDefault(1); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void ElementAtOrDefault4() + { + var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(1); + Assert.AreEqual(42, res.Result); + } + + [TestMethod] + public void ElementAtOrDefault5() + { + var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(7); + Assert.AreEqual(0, res.Result); + } + + [TestMethod] + public void ElementAtOrDefault6() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).ElementAtOrDefault(15); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ToList_Null() + { + AssertThrows(() => AsyncEnumerable.ToList(null)); + AssertThrows(() => AsyncEnumerable.ToList(null, CancellationToken.None)); + } + + [TestMethod] + public void ToList1() + { + var xs = new[] { 42, 25, 39 }; + var res = xs.ToAsyncEnumerable().ToList(); + Assert.IsTrue(res.Result.SequenceEqual(xs)); + } + + [TestMethod] + public void ToList2() + { + var xs = AsyncEnumerable.Empty(); + var res = xs.ToList(); + Assert.IsTrue(res.Result.Count == 0); + } + + [TestMethod] + public void ToList3() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).ToList(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ToArray_Null() + { + AssertThrows(() => AsyncEnumerable.ToArray(null)); + AssertThrows(() => AsyncEnumerable.ToArray(null, CancellationToken.None)); + } + + [TestMethod] + public void ToArray1() + { + var xs = new[] { 42, 25, 39 }; + var res = xs.ToAsyncEnumerable().ToArray(); + Assert.IsTrue(res.Result.SequenceEqual(xs)); + } + + [TestMethod] + public void ToArray2() + { + var xs = AsyncEnumerable.Empty(); + var res = xs.ToArray(); + Assert.IsTrue(res.Result.Length == 0); + } + + [TestMethod] + public void ToArray3() + { + var ex = new Exception("Bang!"); + var res = AsyncEnumerable.Throw(ex).ToArray(); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ToDictionary_Null() + { + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, x => 0, null)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None)); + } + + [TestMethod] + public void ToDictionary1() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToDictionary(x => x % 2).Result; + Assert.IsTrue(res[0] == 4); + Assert.IsTrue(res[1] == 1); + } + + [TestMethod] + public void ToDictionary2() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + AssertThrows(() => xs.ToDictionary(x => x % 2).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException); + } + + [TestMethod] + public void ToDictionary3() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToDictionary(x => x % 2, x => x + 1).Result; + Assert.IsTrue(res[0] == 5); + Assert.IsTrue(res[1] == 2); + } + + [TestMethod] + public void ToDictionary4() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + AssertThrows(() => xs.ToDictionary(x => x % 2, x => x + 1).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException); + } + + [TestMethod] + public void ToDictionary5() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToDictionary(x => x % 2, new Eq()).Result; + Assert.IsTrue(res[0] == 4); + Assert.IsTrue(res[1] == 1); + } + + [TestMethod] + public void ToDictionary6() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + AssertThrows(() => xs.ToDictionary(x => x % 2, new Eq()).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException); + } + + [TestMethod] + public void ToDictionary7() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToDictionary(x => x % 2, x => x, new Eq()).Result; + Assert.IsTrue(res[0] == 4); + Assert.IsTrue(res[1] == 1); + } + + [TestMethod] + public void ToLookup_Null() + { + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, x => 0, null)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None)); + } + + [TestMethod] + public void ToLookup1() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(4)); + Assert.IsTrue(res[1].Contains(1)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void ToLookup2() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(4)); + Assert.IsTrue(res[0].Contains(2)); + Assert.IsTrue(res[1].Contains(1)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void ToLookup3() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2, x => x + 1).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(5)); + Assert.IsTrue(res[1].Contains(2)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void ToLookup4() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2, x => x + 1).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(5)); + Assert.IsTrue(res[0].Contains(3)); + Assert.IsTrue(res[1].Contains(2)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void ToLookup5() + { + var xs = new[] { 1, 4 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2, new Eq()).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(4)); + Assert.IsTrue(res[1].Contains(1)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void ToLookup6() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2, new Eq()).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(4)); + Assert.IsTrue(res[0].Contains(2)); + Assert.IsTrue(res[1].Contains(1)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void ToLookup7() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2).Result; + foreach (var g in res) + Assert.IsTrue(g.Key == 0 || g.Key == 1); + } + + [TestMethod] + public void ToLookup8() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2).Result; + foreach (IGrouping g in (IEnumerable)res) + Assert.IsTrue(g.Key == 0 || g.Key == 1); + } + + [TestMethod] + public void ToLookup9() + { + var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); + var res = xs.ToLookup(x => x % 2, x => x, new Eq()).Result; + Assert.IsTrue(res.Contains(0)); + Assert.IsTrue(res.Contains(1)); + Assert.IsTrue(res[0].Contains(4)); + Assert.IsTrue(res[0].Contains(2)); + Assert.IsTrue(res[1].Contains(1)); + Assert.IsTrue(res.Count == 2); + } + + [TestMethod] + public void Average_Null() + { + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); + + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); + + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); + + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + } + + [TestMethod] + public void Average1() + { + var xs = new[] { 1, 2, 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average2() + { + var xs = new[] { 1, default(int?), 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average3() + { + var xs = new[] { 1L, 2L, 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average4() + { + var xs = new[] { 1L, default(long?), 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average5() + { + var xs = new[] { 1.0, 2.0, 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average6() + { + var xs = new[] { 1.0, default(double?), 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average7() + { + var xs = new[] { 1.0f, 2.0f, 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average8() + { + var xs = new[] { 1.0f, default(float?), 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average9() + { + var xs = new[] { 1.0m, 2.0m, 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average10() + { + var xs = new[] { 1.0m, default(decimal?), 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Average(), ys.Average().Result); + Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); + } + + [TestMethod] + public void Average11() + { + var xs = new int[0]; + var ys = xs.ToAsyncEnumerable(); + AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Average12() + { + var xs = new int?[0]; + var ys = xs.ToAsyncEnumerable(); + Assert.IsNull(ys.Average().Result); + } + + [TestMethod] + public void Average13() + { + var xs = new long[0]; + var ys = xs.ToAsyncEnumerable(); + AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Average14() + { + var xs = new long?[0]; + var ys = xs.ToAsyncEnumerable(); + Assert.IsNull(ys.Average().Result); + } + + [TestMethod] + public void Average15() + { + var xs = new double[0]; + var ys = xs.ToAsyncEnumerable(); + AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Average16() + { + var xs = new double?[0]; + var ys = xs.ToAsyncEnumerable(); + Assert.IsNull(ys.Average().Result); + } + + [TestMethod] + public void Average17() + { + var xs = new float[0]; + var ys = xs.ToAsyncEnumerable(); + AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Average18() + { + var xs = new float?[0]; + var ys = xs.ToAsyncEnumerable(); + Assert.IsNull(ys.Average().Result); + } + + [TestMethod] + public void Average19() + { + var xs = new decimal[0]; + var ys = xs.ToAsyncEnumerable(); + AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void Average20() + { + var xs = new decimal?[0]; + var ys = xs.ToAsyncEnumerable(); + Assert.IsNull(ys.Average().Result); + } + + [TestMethod] + public void Min_Null() + { + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), Comparer.Default)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(IComparer))); + + AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), Comparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(IComparer), CancellationToken.None)); + } + + [TestMethod] + public void Min1() + { + var xs = new[] { 2, 1, 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min2() + { + var xs = new[] { 2, default(int?), 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min3() + { + var xs = new[] { 2L, 1L, 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min4() + { + var xs = new[] { 2L, default(long?), 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min5() + { + var xs = new[] { 2.0, 1.0, 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min6() + { + var xs = new[] { 2.0, default(double?), 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min7() + { + var xs = new[] { 2.0f, 1.0f, 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min8() + { + var xs = new[] { 2.0f, default(float?), 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min9() + { + var xs = new[] { 2.0m, 1.0m, 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min10() + { + var xs = new[] { 2.0m, default(decimal?), 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Min11() + { + var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Min(), ys.Min().Result); + Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); + } + + [TestMethod] + public void Max_Null() + { + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), Comparer.Default)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(IComparer))); + + AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), Comparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(IComparer), CancellationToken.None)); + } + + [TestMethod] + public void Max1() + { + var xs = new[] { 2, 7, 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max2() + { + var xs = new[] { 2, default(int?), 3, 1 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max3() + { + var xs = new[] { 2L, 7L, 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max4() + { + var xs = new[] { 2L, default(long?), 3L, 1L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max5() + { + var xs = new[] { 2.0, 7.0, 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max6() + { + var xs = new[] { 2.0, default(double?), 3.0, 1.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max7() + { + var xs = new[] { 2.0f, 7.0f, 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max8() + { + var xs = new[] { 2.0f, default(float?), 3.0f, 1.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max9() + { + var xs = new[] { 2.0m, 7.0m, 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max10() + { + var xs = new[] { 2.0m, default(decimal?), 3.0m, 1.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Max11() + { + var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Max(), ys.Max().Result); + Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); + } + + [TestMethod] + public void Sum_Null() + { + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); + + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); + + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); + + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); + } + + [TestMethod] + public void Sum1() + { + var xs = new[] { 1, 2, 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum2() + { + var xs = new[] { 1, default(int?), 3 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum3() + { + var xs = new[] { 1L, 2L, 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum4() + { + var xs = new[] { 1L, default(long?), 3L }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum5() + { + var xs = new[] { 1.0, 2.0, 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum6() + { + var xs = new[] { 1.0, default(double?), 3.0 }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum7() + { + var xs = new[] { 1.0f, 2.0f, 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum8() + { + var xs = new[] { 1.0f, default(float?), 3.0f }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum9() + { + var xs = new[] { 1.0m, 2.0m, 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void Sum10() + { + var xs = new[] { 1.0m, default(decimal?), 3.0m }; + var ys = xs.ToAsyncEnumerable(); + Assert.AreEqual(xs.Sum(), ys.Sum().Result); + Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); + } + + [TestMethod] + public void MinBy_Null() + { + AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func))); + + AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default)); + AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer))); + + AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x, Comparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer), CancellationToken.None)); + } + + [TestMethod] + public void MinBy1() + { + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => x / 2); + var res = xs.Result; + + Assert.IsTrue(res.SequenceEqual(new[] { 3, 2 })); + } + + [TestMethod] + public void MinBy2() + { + var xs = new int[0].ToAsyncEnumerable().MinBy(x => x / 2); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void MinBy3() + { + var ex = new Exception("Bang!"); + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 3) throw ex; return x; }); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void MinBy4() + { + var ex = new Exception("Bang!"); + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 4) throw ex; return x; }); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void MinBy5() + { + var ex = new Exception("Bang!"); + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)).MinBy(x => x, Comparer.Default); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void MaxBy_Null() + { + AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func))); + + AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default)); + AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer))); + + AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func), CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x, Comparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer), CancellationToken.None)); + } + + [TestMethod] + public void MaxBy1() + { + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => x / 2); + var res = xs.Result; + + Assert.IsTrue(res.SequenceEqual(new[] { 7, 6 })); + } + + [TestMethod] + public void MaxBy2() + { + var xs = new int[0].ToAsyncEnumerable().MaxBy(x => x / 2); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); + } + + [TestMethod] + public void MaxBy3() + { + var ex = new Exception("Bang!"); + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 3) throw ex; return x; }); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void MaxBy4() + { + var ex = new Exception("Bang!"); + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 4) throw ex; return x; }); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void MaxBy5() + { + var ex = new Exception("Bang!"); + var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)).MaxBy(x => x, Comparer.Default); + + AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Bugs.cs b/Ix/Tests/AsyncTests.Bugs.cs new file mode 100644 index 0000000..61ae7aa --- /dev/null +++ b/Ix/Tests/AsyncTests.Bugs.cs @@ -0,0 +1,266 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Collections; +using System.Threading; +using System.Threading.Tasks; +using System.Diagnostics; +//using System.Reactive.Linq; +//using System.Reactive.Concurrency; + +namespace Tests +{ + public partial class AsyncTests + { + [TestInitialize] + public void InitTests() + { + TaskScheduler.UnobservedTaskException += (o, e) => + { + }; + } + + /* + [TestMethod] + public void TestPushPopAsync() + { + var stack = new Stack(); + var count = 10; + + var observable = Observable.Generate( + 0, + i => i < count, + i => i + 1, + i => i, + i => TimeSpan.FromMilliseconds(1), // change this to 0 to avoid the problem [1] + Scheduler.ThreadPool); + + var task = DoSomethingAsync(observable, stack); + + // we give it a timeout so the test can fail instead of hang + task.Wait(TimeSpan.FromSeconds(2)); + + Assert.AreEqual(10, stack.Count); + } + + private Task DoSomethingAsync(IObservable observable, Stack stack) + { + var ae = observable + .ToAsyncEnumerable() + //.Do(i => Debug.WriteLine("Bug-fixing side effect: " + i)) // [2] + .GetEnumerator(); + + var tcs = new TaskCompletionSource(); + + var a = default(Action); + a = new Action(() => + { + ae.MoveNext().ContinueWith(t => + { + if (t.Result) + { + var i = ae.Current; + Debug.WriteLine("Doing something with " + i); + Thread.Sleep(50); + stack.Push(i); + a(); + } + else + tcs.TrySetResult(null); + }); + }); + + a(); + + return tcs.Task; + } + */ + + static IEnumerable Xs(Action a) + { + try + { + var rnd = new Random(); + + while (true) + { + yield return rnd.Next(0, 43); + Thread.Sleep(rnd.Next(0, 500)); + } + } + finally + { + a(); + } + } + + [TestMethod] + public void CorrectDispose() + { + var disposed = false; + + var xs = new[] { 1, 2, 3 }.WithDispose(() => + { + disposed = true; + }).ToAsyncEnumerable(); + + var ys = xs.Select(x => x + 1); + + var e = ys.GetEnumerator(); + e.Dispose(); + + Assert.IsTrue(disposed); + + Assert.IsFalse(e.MoveNext().Result); + } + + [TestMethod] + public void DisposesUponError() + { + var disposed = false; + + var xs = new[] { 1, 2, 3 }.WithDispose(() => + { + disposed = true; + }).ToAsyncEnumerable(); + + var ex = new Exception("Bang!"); + var ys = xs.Select(x => { if (x == 1) throw ex; return x; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext()); + + Assert.IsTrue(disposed); + } + + [TestMethod] + public void CorrectCancel() + { + var disposed = false; + + var xs = new[] { 1, 2, 3 }.WithDispose(() => + { + disposed = true; + }).ToAsyncEnumerable(); + + var ys = xs.Select(x => x + 1).Where(x => true); + + var e = ys.GetEnumerator(); + var cts = new CancellationTokenSource(); + var t = e.MoveNext(cts.Token); + + cts.Cancel(); + + try + { + t.Wait(); + } + catch + { + // Don't care about the outcome; we could have made it to element 1 + // but we could also have cancelled the MoveNext-calling task. Either + // way, we want to wait for the task to be completed and check that + } + finally + { + // the cancellation bubbled all the way up to the source to dispose + // it. This design is chosen because cancelling a MoveNext call leaves + // the enumerator in an indeterminate state. Further interactions with + // it should be forbidden. + Assert.IsTrue(disposed); + } + + Assert.IsFalse(e.MoveNext().Result); + } + + [TestMethod] + public void CanCancelMoveNext() + { + var evt = new ManualResetEvent(false); + var xs = Blocking(evt).ToAsyncEnumerable().Select(x => x).Where(x => true); + + var e = xs.GetEnumerator(); + var cts = new CancellationTokenSource(); + var t = e.MoveNext(cts.Token); + + cts.Cancel(); + + try + { + t.Wait(); + Assert.Fail(); + } + catch + { + Assert.IsTrue(t.IsCanceled); + } + + evt.Set(); + } + + static IEnumerable Blocking(ManualResetEvent evt) + { + evt.WaitOne(); + yield return 42; + } + } + + static class MyExt + { + public static IEnumerable WithDispose(this IEnumerable source, Action a) + { + return EnumerableEx.Create(() => + { + var e = source.GetEnumerator(); + return new Enumerator(e.MoveNext, () => e.Current, () => { e.Dispose(); a(); }); + }); + } + + class Enumerator : IEnumerator + { + private readonly Func _moveNext; + private readonly Func _current; + private readonly Action _dispose; + + public Enumerator(Func moveNext, Func current, Action dispose) + { + _moveNext = moveNext; + _current = current; + _dispose = dispose; + } + + public T Current + { + get { return _current(); } + } + + public void Dispose() + { + _dispose(); + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + return _moveNext(); + } + + public void Reset() + { + throw new NotImplementedException(); + } + } + + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Conversions.cs b/Ix/Tests/AsyncTests.Conversions.cs new file mode 100644 index 0000000..1c1c2a2 --- /dev/null +++ b/Ix/Tests/AsyncTests.Conversions.cs @@ -0,0 +1,312 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Threading; + +namespace Tests +{ + public partial class AsyncTests + { + [TestMethod] + public void ToAsyncEnumerable_Null() + { + AssertThrows(() => AsyncEnumerable.ToAsyncEnumerable(default(IEnumerable))); + AssertThrows(() => AsyncEnumerable.ToAsyncEnumerable(default(IObservable))); + } + + [TestMethod] + public void ToAsyncEnumerable1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void ToAsyncEnumerable2() + { + var ex = new Exception("Bang"); + var xs = ToAsyncEnumerable_Sequence(ex).ToAsyncEnumerable(); + var e = xs.GetEnumerator(); + HasNext(e, 42); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + } + + private IEnumerable ToAsyncEnumerable_Sequence(Exception e) + { + yield return 42; + throw e; + } + + [TestMethod] + public void ToAsyncEnumerable3() + { + var subscribed = false; + + var xs = new MyObservable(obs => + { + subscribed = true; + + obs.OnNext(42); + obs.OnCompleted(); + + return new MyDisposable(() => { }); + }).ToAsyncEnumerable(); + + Assert.IsFalse(subscribed); + + var e = xs.GetEnumerator(); + + Assert.IsTrue(subscribed); + + HasNext(e, 42); + NoNext(e); + } + + [TestMethod] + public void ToAsyncEnumerable4() + { + var ex = new Exception("Bang!"); + var subscribed = false; + + var xs = new MyObservable(obs => + { + subscribed = true; + + obs.OnError(ex); + + return new MyDisposable(() => { }); + }).ToAsyncEnumerable(); + + Assert.IsFalse(subscribed); + + var e = xs.GetEnumerator(); + + Assert.IsTrue(subscribed); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + } + + class MyObservable : IObservable + { + private Func, IDisposable> _subscribe; + + public MyObservable(Func, IDisposable> subscribe) + { + _subscribe = subscribe; + } + + public IDisposable Subscribe(IObserver observer) + { + return _subscribe(observer); + } + } + + class MyDisposable : IDisposable + { + private Action _dispose; + + public MyDisposable(Action dispose) + { + _dispose = dispose; + } + + public void Dispose() + { + _dispose(); + } + } + + [TestMethod] + public void ToEnumerable_Null() + { + AssertThrows(() => AsyncEnumerable.ToEnumerable(null)); + } + + [TestMethod] + public void ToEnumerable1() + { + var xs = AsyncEnumerable.Return(42).ToEnumerable(); + Assert.IsTrue(xs.SequenceEqual(new[] { 42 })); + } + + [TestMethod] + public void ToEnumerable2() + { + var xs = AsyncEnumerable.Empty().ToEnumerable(); + Assert.IsTrue(xs.SequenceEqual(new int[0])); + } + + [TestMethod] + public void ToEnumerable3() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex).ToEnumerable(); + AssertThrows(() => xs.GetEnumerator().MoveNext(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + } + +#if !NO_RXINTERFACES + [TestMethod] + public void ToObservable_Null() + { + AssertThrows(() => AsyncEnumerable.ToObservable(null)); + } + + [TestMethod] + public void ToObservable1() + { + var fail = false; + var evt = new ManualResetEvent(false); + + var xs = AsyncEnumerable.Empty().ToObservable(); + xs.Subscribe(new MyObserver( + x => + { + fail = true; + }, + ex => + { + fail = true; + evt.Set(); + }, + () => + { + evt.Set(); + } + )); + + evt.WaitOne(); + Assert.IsFalse(fail); + } + + [TestMethod] + public void ToObservable2() + { + var lst = new List(); + var fail = false; + var evt = new ManualResetEvent(false); + + var xs = AsyncEnumerable.Return(42).ToObservable(); + xs.Subscribe(new MyObserver( + x => + { + lst.Add(x); + }, + ex => + { + fail = true; + evt.Set(); + }, + () => + { + evt.Set(); + } + )); + + evt.WaitOne(); + Assert.IsFalse(fail); + Assert.IsTrue(lst.SequenceEqual(new[] { 42 })); + } + + [TestMethod] + public void ToObservable3() + { + var lst = new List(); + var fail = false; + var evt = new ManualResetEvent(false); + + var xs = AsyncEnumerable.Range(0, 10).ToObservable(); + xs.Subscribe(new MyObserver( + x => + { + lst.Add(x); + }, + ex => + { + fail = true; + evt.Set(); + }, + () => + { + evt.Set(); + } + )); + + evt.WaitOne(); + Assert.IsFalse(fail); + Assert.IsTrue(lst.SequenceEqual(Enumerable.Range(0, 10))); + } + + [TestMethod] + public void ToObservable4() + { + var ex1 = new Exception("Bang!"); + var ex_ = default(Exception); + var fail = false; + var evt = new ManualResetEvent(false); + + var xs = AsyncEnumerable.Throw(ex1).ToObservable(); + xs.Subscribe(new MyObserver( + x => + { + fail = true; + }, + ex => + { + ex_ = ex; + evt.Set(); + }, + () => + { + fail = true; + evt.Set(); + } + )); + + evt.WaitOne(); + Assert.IsFalse(fail); + Assert.AreEqual(ex1, ((AggregateException)ex_).InnerExceptions.Single()); + } + + class MyObserver : IObserver + { + private Action _onNext; + private Action _onError; + private Action _onCompleted; + + public MyObserver(Action onNext, Action onError, Action onCompleted) + { + _onNext = onNext; + _onError = onError; + _onCompleted = onCompleted; + } + + public void OnCompleted() + { + _onCompleted(); + } + + public void OnError(Exception error) + { + _onError(error); + } + + public void OnNext(T value) + { + _onNext(value); + } + } +#endif + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Creation.cs b/Ix/Tests/AsyncTests.Creation.cs new file mode 100644 index 0000000..32e849a --- /dev/null +++ b/Ix/Tests/AsyncTests.Creation.cs @@ -0,0 +1,409 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Threading.Tasks; +using System.Threading; + +namespace Tests +{ + static class Ext + { + public static Task MoveNext(this IAsyncEnumerator enumerator) + { + return enumerator.MoveNext(CancellationToken.None); + } + } + + public partial class AsyncTests + { + [TestMethod] + public void Return() + { + var xs = AsyncEnumerable.Return(42); + HasNext(xs.GetEnumerator(), 42); + } + + [TestMethod] + public void Never() + { + var xs = AsyncEnumerable.Never(); + + var e = xs.GetEnumerator(); + Assert.IsFalse(e.MoveNext().IsCompleted); // Very rudimentary check + AssertThrows(() => Nop(e.Current)); + e.Dispose(); + } + + [TestMethod] + public void Empty1() + { + var xs = AsyncEnumerable.Empty(); + NoNext(xs.GetEnumerator()); + } + + [TestMethod] + public void Empty2() + { + var xs = AsyncEnumerable.Empty(); + + var e = xs.GetEnumerator(); + Assert.IsFalse(e.MoveNext().Result); + AssertThrows(() => Nop(e.Current)); + } + + [TestMethod] + public void Throw_Null() + { + AssertThrows(() => AsyncEnumerable.Throw(null)); + } + + [TestMethod] + public void Throw() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + AssertThrows(() => Nop(e.Current)); + } + + private void Nop(object o) + { + } + + [TestMethod] + public void Range_Null() + { + AssertThrows(() => AsyncEnumerable.Range(0, -1)); + } + + [TestMethod] + public void Range1() + { + var xs = AsyncEnumerable.Range(2, 5); + + var e = xs.GetEnumerator(); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Range2() + { + var xs = AsyncEnumerable.Range(2, 0); + + var e = xs.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Repeat_Null() + { + AssertThrows(() => AsyncEnumerable.Repeat(0, -1)); + } + + [TestMethod] + public void Repeat1() + { + var xs = AsyncEnumerable.Repeat(2, 5); + + var e = xs.GetEnumerator(); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void Repeat2() + { + var xs = AsyncEnumerable.Repeat(2, 0); + + var e = xs.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Repeat3() + { + var xs = AsyncEnumerable.Repeat(2); + + var e = xs.GetEnumerator(); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 2); + e.Dispose(); + } + + [TestMethod] + public void Defer_Null() + { + AssertThrows(() => AsyncEnumerable.Defer(null)); + } + + [TestMethod] + public void Defer1() + { + var x = 0; + var xs = AsyncEnumerable.Defer(() => new[] { x }.ToAsyncEnumerable()); + + { + var e = xs.GetEnumerator(); + HasNext(e, 0); + NoNext(e); + } + + { + x++; + var e = xs.GetEnumerator(); + HasNext(e, 1); + NoNext(e); + } + } + + [TestMethod] + public void Generate_Null() + { + AssertThrows(() => AsyncEnumerable.Generate(0, null, x => x, x => x)); + AssertThrows(() => AsyncEnumerable.Generate(0, x => true, null, x => x)); + AssertThrows(() => AsyncEnumerable.Generate(0, x => true, x => x, null)); + } + + [TestMethod] + public void Generate1() + { + var xs = AsyncEnumerable.Generate(0, x => x < 5, x => x + 1, x => x * x); + + var e = xs.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 1); + HasNext(e, 4); + HasNext(e, 9); + HasNext(e, 16); + NoNext(e); + e.Dispose(); + } + + [TestMethod] + public void Generate2() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Generate(0, x => { throw ex; }, x => x + 1, x => x * x); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Generate3() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Generate(0, x => true, x => x + 1, x => { if (x == 1) throw ex; return x * x; }); + + var e = xs.GetEnumerator(); + HasNext(e, 0); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Generate4() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Generate(0, x => true, x => { throw ex; }, x => x * x); + + var e = xs.GetEnumerator(); + HasNext(e, 0); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Using_Null() + { + AssertThrows(() => AsyncEnumerable.Using(null, _ => null)); + AssertThrows(() => AsyncEnumerable.Using(() => new MyD(null), null)); + } + + [TestMethod] + public void Using1() + { + var i = 0; + var d = 0; + + var xs = AsyncEnumerable.Using( + () => + { + i++; + return new MyD(() => { d++; }); + }, + _ => AsyncEnumerable.Return(42) + ); + + Assert.AreEqual(0, i); + + var e = xs.GetEnumerator(); + Assert.AreEqual(1, i); + } + + [TestMethod] + public void Using2() + { + var i = 0; + var d = 0; + + var xs = AsyncEnumerable.Using( + () => + { + i++; + return new MyD(() => { d++; }); + }, + _ => AsyncEnumerable.Return(42) + ); + + Assert.AreEqual(0, i); + + var e = xs.GetEnumerator(); + Assert.AreEqual(1, i); + + e.Dispose(); + Assert.AreEqual(1, d); + } + + [TestMethod] + public void Using3() + { + var ex = new Exception("Bang!"); + var i = 0; + var d = 0; + + var xs = AsyncEnumerable.Using( + () => + { + i++; + return new MyD(() => { d++; }); + }, + _ => { throw ex; } + ); + + Assert.AreEqual(0, i); + + AssertThrows(() => xs.GetEnumerator(), ex_ => ex_ == ex); + + Assert.AreEqual(1, d); + } + + [TestMethod] + public void Using4() + { + var i = 0; + var disposed = false; + + var xs = AsyncEnumerable.Using( + () => + { + i++; + return new MyD(() => { disposed = true; }); + }, + _ => AsyncEnumerable.Return(42) + ); + + Assert.AreEqual(0, i); + + var e = xs.GetEnumerator(); + Assert.AreEqual(1, i); + + HasNext(e, 42); + NoNext(e); + + Assert.IsTrue(disposed); + } + + [TestMethod] + public void Using5() + { + var ex = new Exception("Bang!"); + var i = 0; + var disposed = false; + + var xs = AsyncEnumerable.Using( + () => + { + i++; + return new MyD(() => { disposed = true; }); + }, + _ => AsyncEnumerable.Throw(ex) + ); + + Assert.AreEqual(0, i); + + var e = xs.GetEnumerator(); + Assert.AreEqual(1, i); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + + Assert.IsTrue(disposed); + } + + [TestMethod] + public void Using6() + { + var i = 0; + var disposed = false; + + var xs = AsyncEnumerable.Using( + () => + { + i++; + return new MyD(() => { disposed = true; }); + }, + _ => AsyncEnumerable.Range(0, 10) + ); + + Assert.AreEqual(0, i); + + var e = xs.GetEnumerator(); + Assert.AreEqual(1, i); + + HasNext(e, 0); + HasNext(e, 1); + + var cts = new CancellationTokenSource(); + var t = e.MoveNext(cts.Token); + cts.Cancel(); + + t.Wait(); + + Assert.IsTrue(disposed); + } + + class MyD : IDisposable + { + private readonly Action _dispose; + + public MyD(Action dispose) + { + _dispose = dispose; + } + + public void Dispose() + { + _dispose(); + } + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Exceptions.cs b/Ix/Tests/AsyncTests.Exceptions.cs new file mode 100644 index 0000000..f7c8a8f --- /dev/null +++ b/Ix/Tests/AsyncTests.Exceptions.cs @@ -0,0 +1,551 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Threading; + +namespace Tests +{ + public partial class AsyncTests + { + [TestMethod] + public void Catch_Null() + { + AssertThrows(() => AsyncEnumerable.Catch(default(IAsyncEnumerable), x => null)); + AssertThrows(() => AsyncEnumerable.Catch(AsyncEnumerable.Return(42), default(Func>))); + + AssertThrows(() => AsyncEnumerable.Catch(default(IAsyncEnumerable), AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.Catch(AsyncEnumerable.Return(42), default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Catch(default(IAsyncEnumerable[]))); + AssertThrows(() => AsyncEnumerable.Catch(default(IEnumerable>))); + } + + [TestMethod] + public void Catch1() + { + var err = false; + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = xs.Catch(ex_ => { err = true; return ys; }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + NoNext(e); + + Assert.IsFalse(err); + } + + [TestMethod] + public void Catch2() + { + var ex = new InvalidOperationException("Bang!"); + + var err = false; + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = xs.Catch(ex_ => { err = true; return ys; }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + Assert.IsFalse(err); + + HasNext(e, 4); + + Assert.IsTrue(err); + + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Catch3() + { + var ex = new InvalidOperationException("Bang!"); + + var err = false; + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = xs.Catch(ex_ => { err = true; return ys; }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + Assert.IsFalse(err); + + HasNext(e, 4); + + Assert.IsTrue(err); + + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Catch4() + { + var ex = new DivideByZeroException(); + + var err = false; + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = xs.Catch(ex_ => { err = true; return ys; }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + + Assert.IsFalse(err); + } + + [TestMethod] + public void Catch5() + { + var ex = new InvalidOperationException("Bang!"); + var ex2 = new Exception("Oops!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = xs.Catch(ex_ => { if (ex_.Message == "Bang!") throw ex2; return ys; }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex2); + } + + [TestMethod] + public void Catch6() + { + var ex = new InvalidOperationException("Bang!"); + + var err = false; + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + + var res = xs.Catch(ex_ => { err = true; return xs; }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + Assert.IsFalse(err); + + HasNext(e, 1); + + Assert.IsTrue(err); + + HasNext(e, 2); + HasNext(e, 3); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Catch7() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.Catch(xs, ys); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + NoNext(e); + } + + [TestMethod] + public void Catch8() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.Catch(xs, ys); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Catch9() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.Catch(new[] { xs, xs, ys, ys }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Catch10() + { + var res = CatchXss().Catch(); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + } + + private IEnumerable> CatchXss() + { + yield return new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(new Exception("!!!"))); + throw new Exception("Bang!"); + } + + [TestMethod] + public void Catch11() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + + var res = AsyncEnumerable.Catch(new[] { xs, xs }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Catch12() + { + var res = AsyncEnumerable.Catch(Enumerable.Empty>()); + + var e = res.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Finally_Null() + { + AssertThrows(() => AsyncEnumerable.Finally(default(IAsyncEnumerable), () => { })); + AssertThrows(() => AsyncEnumerable.Finally(AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Finally1() + { + var b = false; + + var xs = AsyncEnumerable.Empty().Finally(() => { b = true; }); + + var e = xs.GetEnumerator(); + + Assert.IsFalse(b); + NoNext(e); + + Assert.IsTrue(b); + } + + [TestMethod] + public void Finally2() + { + var b = false; + + var xs = AsyncEnumerable.Return(42).Finally(() => { b = true; }); + + var e = xs.GetEnumerator(); + + Assert.IsFalse(b); + HasNext(e, 42); + + Assert.IsFalse(b); + NoNext(e); + + Assert.IsTrue(b); + } + + [TestMethod] + public void Finally3() + { + var ex = new Exception("Bang!"); + + var b = false; + + var xs = AsyncEnumerable.Throw(ex).Finally(() => { b = true; }); + + var e = xs.GetEnumerator(); + + Assert.IsFalse(b); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + + Assert.IsTrue(b); + } + + [TestMethod] + public void Finally4() + { + var b = false; + + var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { b = true; }); + + var e = xs.GetEnumerator(); + + Assert.IsFalse(b); + HasNext(e, 1); + + Assert.IsFalse(b); + HasNext(e, 2); + + Assert.IsFalse(b); + NoNext(e); + + Assert.IsTrue(b); + } + + [TestMethod] + public void Finally5() + { + var b = false; + + var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { b = true; }); + + var e = xs.GetEnumerator(); + + Assert.IsFalse(b); + HasNext(e, 1); + + e.Dispose(); + + Assert.IsTrue(b); + } + + [TestMethod] + public void Finally6() + { + var b = false; + + var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { b = true; }); + + var e = xs.GetEnumerator(); + + var cts = new CancellationTokenSource(); + + var t = e.MoveNext(cts.Token); + cts.Cancel(); + t.Wait(); + + Assert.IsTrue(b); + } + + [TestMethod] + public void OnErrorResumeNext_Null() + { + AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(default(IAsyncEnumerable), AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(AsyncEnumerable.Return(42), default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(default(IAsyncEnumerable[]))); + AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(default(IEnumerable>))); + } + + [TestMethod] + public void OnErrorResumeNext7() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.OnErrorResumeNext(xs, ys); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void OnErrorResumeNext8() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.OnErrorResumeNext(xs, ys); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void OnErrorResumeNext9() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.OnErrorResumeNext(new[] { xs, xs, ys, ys }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void OnErrorResumeNext10() + { + var res = OnErrorResumeNextXss().OnErrorResumeNext(); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + } + + private IEnumerable> OnErrorResumeNextXss() + { + yield return new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(new Exception("!!!"))); + throw new Exception("Bang!"); + } + + [TestMethod] + public void OnErrorResumeNext11() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + + var res = AsyncEnumerable.OnErrorResumeNext(new[] { xs, xs }); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + NoNext(e); + } + + [TestMethod] + public void OnErrorResumeNext12() + { + var res = AsyncEnumerable.OnErrorResumeNext(Enumerable.Empty>()); + + var e = res.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Retry_Null() + { + AssertThrows(() => AsyncEnumerable.Retry(default(IAsyncEnumerable))); + + AssertThrows(() => AsyncEnumerable.Retry(default(IAsyncEnumerable), 1)); + AssertThrows(() => AsyncEnumerable.Retry(AsyncEnumerable.Return(42), -1)); + } + + [TestMethod] + public void Retry1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + + var res = xs.Retry(); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + NoNext(e); + } + + [TestMethod] + public void Retry2() + { + var ex = new InvalidOperationException("Bang!"); + + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + + var res = xs.Retry(); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Multiple.cs b/Ix/Tests/AsyncTests.Multiple.cs new file mode 100644 index 0000000..1ddd56f --- /dev/null +++ b/Ix/Tests/AsyncTests.Multiple.cs @@ -0,0 +1,787 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Threading; + +namespace Tests +{ + public partial class AsyncTests + { + [TestMethod] + public void Concat_Null() + { + AssertThrows(() => AsyncEnumerable.Concat(null, AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.Concat(AsyncEnumerable.Return(42), null)); + AssertThrows(() => AsyncEnumerable.Concat(default(IAsyncEnumerable[]))); + AssertThrows(() => AsyncEnumerable.Concat(default(IEnumerable>))); + } + + [TestMethod] + public void Concat1() + { + var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable()); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Concat2() + { + var ex = new Exception("Bang"); + var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Concat3() + { + var ex = new Exception("Bang"); + var ys = AsyncEnumerable.Throw(ex).Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable()); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Concat4() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5 }.ToAsyncEnumerable(); + var zs = new[] { 6, 7, 8 }.ToAsyncEnumerable(); + + var res = AsyncEnumerable.Concat(xs, ys, zs); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + HasNext(e, 7); + HasNext(e, 8); + NoNext(e); + } + + [TestMethod] + public void Concat5() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5 }.ToAsyncEnumerable(); + var zs = AsyncEnumerable.Throw(ex); + + var res = AsyncEnumerable.Concat(xs, ys, zs); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Concat6() + { + var res = AsyncEnumerable.Concat(ConcatXss()); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + } + + static IEnumerable> ConcatXss() + { + yield return new[] { 1, 2, 3 }.ToAsyncEnumerable(); + yield return new[] { 4, 5 }.ToAsyncEnumerable(); + throw new Exception("Bang!"); + } + + [TestMethod] + public void Zip_Null() + { + AssertThrows(() => AsyncEnumerable.Zip(null, AsyncEnumerable.Return(42), (x, y) => x + y)); + AssertThrows(() => AsyncEnumerable.Zip(AsyncEnumerable.Return(42), null, (x, y) => x + y)); + AssertThrows(() => AsyncEnumerable.Zip(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Zip1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + var res = xs.Zip(ys, (x, y) => x * y); + + var e = res.GetEnumerator(); + HasNext(e, 1 * 4); + HasNext(e, 2 * 5); + HasNext(e, 3 * 6); + NoNext(e); + } + + [TestMethod] + public void Zip2() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5, 6, 7 }.ToAsyncEnumerable(); + var res = xs.Zip(ys, (x, y) => x * y); + + var e = res.GetEnumerator(); + HasNext(e, 1 * 4); + HasNext(e, 2 * 5); + HasNext(e, 3 * 6); + NoNext(e); + } + + [TestMethod] + public void Zip3() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); + var res = xs.Zip(ys, (x, y) => x * y); + + var e = res.GetEnumerator(); + HasNext(e, 1 * 4); + HasNext(e, 2 * 5); + HasNext(e, 3 * 6); + NoNext(e); + } + + [TestMethod] + public void Zip4() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = AsyncEnumerable.Throw(ex); + var res = xs.Zip(ys, (x, y) => x * y); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Zip5() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.Zip(ys, (x, y) => x * y); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Zip6() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.Zip(ys, (x, y) => { if (x > 0) throw ex; return x * y; }); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Union_Null() + { + AssertThrows(() => AsyncEnumerable.Union(null, AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.Union(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Union(null, AsyncEnumerable.Return(42), new Eq())); + AssertThrows(() => AsyncEnumerable.Union(AsyncEnumerable.Return(42), null, new Eq())); + AssertThrows(() => AsyncEnumerable.Union(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Union1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); + var res = xs.Union(ys); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 5); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Union2() + { + var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable(); + var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable(); + var res = xs.Union(ys, new Eq()); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, -3); + HasNext(e, 5); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Intersect_Null() + { + AssertThrows(() => AsyncEnumerable.Intersect(null, AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.Intersect(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Intersect(null, AsyncEnumerable.Return(42), new Eq())); + AssertThrows(() => AsyncEnumerable.Intersect(AsyncEnumerable.Return(42), null, new Eq())); + AssertThrows(() => AsyncEnumerable.Intersect(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Intersect1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); + var res = xs.Intersect(ys); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 3); + NoNext(e); + } + + [TestMethod] + public void Intersect2() + { + var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable(); + var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable(); + var res = xs.Intersect(ys, new Eq()); + + var e = res.GetEnumerator(); + HasNext(e, 1); + HasNext(e, -3); + NoNext(e); + } + + [TestMethod] + public void Except_Null() + { + AssertThrows(() => AsyncEnumerable.Except(null, AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.Except(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Except(null, AsyncEnumerable.Return(42), new Eq())); + AssertThrows(() => AsyncEnumerable.Except(AsyncEnumerable.Return(42), null, new Eq())); + AssertThrows(() => AsyncEnumerable.Except(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Except1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); + var res = xs.Except(ys); + + var e = res.GetEnumerator(); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void Except2() + { + var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable(); + var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable(); + var res = xs.Except(ys, new Eq()); + + var e = res.GetEnumerator(); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void SequenceEqual_Null() + { + AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42), new Eq())); + AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null, new Eq())); + AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null, CancellationToken.None)); + + AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42), new Eq(), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null, new Eq(), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None)); + } + + [TestMethod] + public void SequenceEqual1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(xs); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void SequenceEqual2() + { + var xs = AsyncEnumerable.Empty(); + var res = xs.SequenceEqual(xs); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void SequenceEqual3() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void SequenceEqual4() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void SequenceEqual5() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void SequenceEqual6() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = AsyncEnumerable.Throw(ex); + var res = xs.SequenceEqual(ys); + + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SequenceEqual7() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys); + + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SequenceEqual8() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(xs, new Eq()); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void SequenceEqual9() + { + var xs = AsyncEnumerable.Empty(); + var res = xs.SequenceEqual(xs, new Eq()); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void SequenceEqual10() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys, new Eq()); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void SequenceEqual11() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys, new Eq()); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void SequenceEqual12() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys, new Eq()); + Assert.IsFalse(res.Result); + } + + [TestMethod] + public void SequenceEqual13() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = AsyncEnumerable.Throw(ex); + var res = xs.SequenceEqual(ys, new Eq()); + + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SequenceEqual14() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys, new Eq()); + + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SequenceEqual15() + { + var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable(); + var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys, new Eq()); + Assert.IsTrue(res.Result); + } + + [TestMethod] + public void SequenceEqual16() + { + var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable(); + var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable(); + var res = xs.SequenceEqual(ys, new EqEx()); + AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException); + } + + class EqEx : IEqualityComparer + { + public bool Equals(int x, int y) + { + throw new NotImplementedException(); + } + + public int GetHashCode(int obj) + { + throw new NotImplementedException(); + } + } + + [TestMethod] + public void GroupJoin_Null() + { + AssertThrows(() => AsyncEnumerable.GroupJoin(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null)); + + AssertThrows(() => AsyncEnumerable.GroupJoin(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer))); + } + + [TestMethod] + public void GroupJoin1() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 4, 7, 6, 2, 3, 4, 8, 9 }.ToAsyncEnumerable(); + + var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); + + var e = res.GetEnumerator(); + HasNext(e, "0 - 639"); + HasNext(e, "1 - 474"); + HasNext(e, "2 - 28"); + NoNext(e); + } + + [TestMethod] + public void GroupJoin2() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + + var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); + + var e = res.GetEnumerator(); + HasNext(e, "0 - 36"); + HasNext(e, "1 - 4"); + HasNext(e, "2 - "); + NoNext(e); + } + + [TestMethod] + public void GroupJoin3() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + + var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupJoin4() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = AsyncEnumerable.Throw(ex); + + var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupJoin5() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + + var res = xs.GroupJoin(ys, x => { throw ex; }, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupJoin6() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + + var res = xs.GroupJoin(ys, x => x % 3, y => { throw ex; }, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupJoin7() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + + var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => { + if (x == 1) + throw ex; + return x + " - " + i.Aggregate("", (s, j) => s + j).Result; + }); + + var e = res.GetEnumerator(); + HasNext(e, "0 - 36"); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Join_Null() + { + AssertThrows(() => AsyncEnumerable.Join(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null)); + + AssertThrows(() => AsyncEnumerable.Join(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer))); + } + + [TestMethod] + public void Join1() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); + + var e = res.GetEnumerator(); + HasNext(e, 0 + 3); + HasNext(e, 0 + 6); + HasNext(e, 1 + 4); + NoNext(e); + } + + [TestMethod] + public void Join2() + { + var xs = new[] { 3, 6, 4 }.ToAsyncEnumerable(); + var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); + + var e = res.GetEnumerator(); + HasNext(e, 3 + 0); + HasNext(e, 6 + 0); + HasNext(e, 4 + 1); + NoNext(e); + } + + [TestMethod] + public void Join3() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 6 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); + + var e = res.GetEnumerator(); + HasNext(e, 0 + 3); + HasNext(e, 0 + 6); + NoNext(e); + } + + [TestMethod] + public void Join4() + { + var xs = new[] { 3, 6 }.ToAsyncEnumerable(); + var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); + + var e = res.GetEnumerator(); + HasNext(e, 3 + 0); + HasNext(e, 6 + 0); + NoNext(e); + } + + [TestMethod] + public void Join5() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Join6() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = AsyncEnumerable.Throw(ex); + + var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Join7() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => { throw ex; }, y => y, (x, y) => x + y); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Join8() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x, y => { throw ex; }, (x, y) => x + y); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Join9() + { + var ex = new Exception("Bang!"); + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + + var res = xs.Join(ys, x => x, y => y, (x, y) => { throw ex; }); + + var e = res.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectManyMultiple_Null() + { + AssertThrows(() => AsyncEnumerable.SelectMany(default(IAsyncEnumerable), AsyncEnumerable.Return(42))); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(IAsyncEnumerable))); + } + + [TestMethod] + public void SelectManyMultiple1() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = new[] { 3, 4 }.ToAsyncEnumerable(); + + var res = xs.SelectMany(ys); + + var e = res.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Single.cs b/Ix/Tests/AsyncTests.Single.cs new file mode 100644 index 0000000..409f48a --- /dev/null +++ b/Ix/Tests/AsyncTests.Single.cs @@ -0,0 +1,2455 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Threading; + +namespace Tests +{ + public partial class AsyncTests + { + [TestMethod] + public void Select_Null() + { + AssertThrows(() => AsyncEnumerable.Select(null, x => x)); + AssertThrows(() => AsyncEnumerable.Select(null, (x, i) => x)); + AssertThrows(() => AsyncEnumerable.Select(AsyncEnumerable.Return(42), default(Func))); + AssertThrows(() => AsyncEnumerable.Select(AsyncEnumerable.Return(42), default(Func))); + } + + [TestMethod] + public void Select1() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = xs.Select(x => (char)('a' + x)); + + var e = ys.GetEnumerator(); + HasNext(e, 'a'); + HasNext(e, 'b'); + HasNext(e, 'c'); + NoNext(e); + } + + [TestMethod] + public void Select2() + { + var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable(); + var ys = xs.Select((x, i) => (char)('a' + i)); + + var e = ys.GetEnumerator(); + HasNext(e, 'a'); + HasNext(e, 'b'); + HasNext(e, 'c'); + NoNext(e); + } + + [TestMethod] + public void Select3() + { + var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); + var ys = xs.Select(x => 1 / x); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException); + } + + [TestMethod] + public void Select4() + { + var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable(); + var ys = xs.Select((x, i) => 1 / i); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException); + } + + [TestMethod] + public void Where_Null() + { + AssertThrows(() => AsyncEnumerable.Where(null, x => true)); + AssertThrows(() => AsyncEnumerable.Where(null, (x, i) => true)); + AssertThrows(() => AsyncEnumerable.Where(AsyncEnumerable.Return(42), default(Func))); + AssertThrows(() => AsyncEnumerable.Where(AsyncEnumerable.Return(42), default(Func))); + } + + [TestMethod] + public void Where1() + { + var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); + var ys = xs.Where(x => x % 2 == 0); + var e = ys.GetEnumerator(); + HasNext(e, 8); + HasNext(e, 4); + HasNext(e, 6); + HasNext(e, 2); + HasNext(e, 0); + NoNext(e); + } + + [TestMethod] + public void Where2() + { + var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); + var ys = xs.Where((x, i) => i % 2 == 0); + + var e = ys.GetEnumerator(); + HasNext(e, 8); + HasNext(e, 7); + HasNext(e, 6); + HasNext(e, 2); + HasNext(e, 0); + NoNext(e); + } + + [TestMethod] + public void Where3() + { + var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); + var ex = new Exception("Bang"); + var ys = xs.Where(x => { if (x == 4) throw ex; return true; }); + + var e = ys.GetEnumerator(); + HasNext(e, 8); + HasNext(e, 5); + HasNext(e, 7); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Where4() + { + var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); + var ex = new Exception("Bang"); + var ys = xs.Where((x, i) => { if (i == 3) throw ex; return true; }); + + var e = ys.GetEnumerator(); + HasNext(e, 8); + HasNext(e, 5); + HasNext(e, 7); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Where5() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Where(x => true); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Where6() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + + var ys = xs.Where((x, i) => true); + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany_Null() + { + AssertThrows(() => AsyncEnumerable.SelectMany(null, x => null)); + AssertThrows(() => AsyncEnumerable.SelectMany(null, (x, i) => null)); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>))); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>))); + + AssertThrows(() => AsyncEnumerable.SelectMany(null, x => null, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.SelectMany(null, (x, i) => null, (x, y) => x)); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>), (x, y) => x)); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>), (x, y) => x)); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), x => null, default(Func))); + AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), (x, i) => null, default(Func))); + } + + [TestMethod] + public void SelectMany1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable()); + + var e = ys.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 0); + HasNext(e, 1); + HasNext(e, 0); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void SelectMany2() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany(x => + { + if (x < 3) + return Enumerable.Range(0, x).ToAsyncEnumerable(); + else + return AsyncEnumerable.Throw(ex); + }); + + var e = ys.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 0); + HasNext(e, 1); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany3() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable()); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany4() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany(x => + { + if (x < 3) + return Enumerable.Range(0, x).ToAsyncEnumerable(); + else + throw ex; + }); + + var e = ys.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 0); + HasNext(e, 1); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany5() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 5, x).ToAsyncEnumerable()); + + var e = ys.GetEnumerator(); + HasNext(e, 5); + HasNext(e, 6); + HasNext(e, 7); + HasNext(e, 7); + HasNext(e, 8); + HasNext(e, 9); + NoNext(e); + } + + [TestMethod] + public void SelectMany6() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany((x, i) => + { + if (i < 2) + return Enumerable.Range(0, x).ToAsyncEnumerable(); + else + return AsyncEnumerable.Throw(ex); + }); + + var e = ys.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 0); + HasNext(e, 1); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany7() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.SelectMany((x, i) => Enumerable.Range(0, x).ToAsyncEnumerable()); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany8() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany((x, i) => + { + if (i < 2) + return Enumerable.Range(0, x).ToAsyncEnumerable(); + else + throw ex; + }); + + var e = ys.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 0); + HasNext(e, 1); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany9() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => x * y); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 6); + HasNext(e, 8); + HasNext(e, 9); + HasNext(e, 12); + HasNext(e, 15); + NoNext(e); + } + + [TestMethod] + public void SelectMany10() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => x * y); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 8); + HasNext(e, 10); + HasNext(e, 15); + HasNext(e, 18); + HasNext(e, 21); + NoNext(e); + } + + [TestMethod] + public void SelectMany11() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => + { + if (x * y > 10) + throw ex; + return x * y; + }); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 6); + HasNext(e, 8); + HasNext(e, 9); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SelectMany12() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => + { + if (x * y > 10) + throw ex; + return x * y; + }); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 8); + HasNext(e, 10); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void OfType_Null() + { + AssertThrows(() => AsyncEnumerable.OfType(null)); + } + + [TestMethod] + public void OfType() + { + var xs = new object[] { 1, 1.2, true, 4, "" }.ToAsyncEnumerable(); + var ys = xs.OfType(); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Cast_Null() + { + AssertThrows(() => AsyncEnumerable.Cast(null)); + } + + [TestMethod] + public void Cast() + { + var xs = new object[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Cast(); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Do_Null() + { + AssertThrows(() => AsyncEnumerable.Do(null, x => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action))); + + AssertThrows(() => AsyncEnumerable.Do(null, x => { }, () => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action), () => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, default(Action))); + + AssertThrows(() => AsyncEnumerable.Do(null, x => { }, ex => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action), ex => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, default(Action))); + + AssertThrows(() => AsyncEnumerable.Do(null, x => { }, ex => { }, () => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action), ex => { }, () => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, default(Action), () => { })); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, ex => { }, default(Action))); + + AssertThrows(() => AsyncEnumerable.Do(null, new MyObs())); + AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(IObserver))); + } + + class MyObs : IObserver + { + public void OnCompleted() + { + throw new NotImplementedException(); + } + + public void OnError(Exception error) + { + throw new NotImplementedException(); + } + + public void OnNext(int value) + { + throw new NotImplementedException(); + } + } + + [TestMethod] + public void Do1() + { + var sum = 0; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Do(x => sum += x); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + Assert.AreEqual(1, sum); + HasNext(e, 2); + Assert.AreEqual(3, sum); + HasNext(e, 3); + Assert.AreEqual(6, sum); + HasNext(e, 4); + Assert.AreEqual(10, sum); + NoNext(e); + } + + [TestMethod] + public void Do2() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Do(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Do3() + { + var sum = 0; + var fail = false; + var done = false; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Do(x => sum += x, ex => { fail = true; }, () => { done = true; }); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + Assert.AreEqual(1, sum); + HasNext(e, 2); + Assert.AreEqual(3, sum); + HasNext(e, 3); + Assert.AreEqual(6, sum); + HasNext(e, 4); + Assert.AreEqual(10, sum); + NoNext(e); + + Assert.IsFalse(fail); + Assert.IsTrue(done); + } + + [TestMethod] + public void Do4() + { + var sum = 0; + var done = false; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Do(x => sum += x, () => { done = true; }); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + Assert.AreEqual(1, sum); + HasNext(e, 2); + Assert.AreEqual(3, sum); + HasNext(e, 3); + Assert.AreEqual(6, sum); + HasNext(e, 4); + Assert.AreEqual(10, sum); + NoNext(e); + + Assert.IsTrue(done); + } + + [TestMethod] + public void Do5() + { + var ex = new Exception("Bang"); + var exa = default(Exception); + var done = false; + var hasv = false; + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; }, () => { done = true; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + + Assert.IsFalse(hasv); + Assert.IsFalse(done); + Assert.AreSame(((AggregateException)exa).Flatten().InnerExceptions.Single(), ex); + } + + [TestMethod] + public void Do6() + { + var ex = new Exception("Bang"); + var exa = default(Exception); + var hasv = false; + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + + Assert.IsFalse(hasv); + Assert.AreSame(((AggregateException)exa).Flatten().InnerExceptions.Single(), ex); + } + + [TestMethod] + public void ForEachAsync_Null() + { + AssertThrows(() => AsyncEnumerable.ForEachAsync(null, x => { })); + AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action))); + AssertThrows(() => AsyncEnumerable.ForEachAsync(null, (x, i) => { })); + AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action))); + + AssertThrows(() => AsyncEnumerable.ForEachAsync(null, x => { }, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ForEachAsync(null, (x, i) => { }, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); + } + + [TestMethod] + public void ForEach_Null() + { + AssertThrows(() => AsyncEnumerable.ForEach(null, x => { })); + AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action))); + AssertThrows(() => AsyncEnumerable.ForEach(null, (x, i) => { })); + AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action))); + + AssertThrows(() => AsyncEnumerable.ForEach(null, x => { }, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ForEach(null, (x, i) => { }, CancellationToken.None)); + AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); + } + + [TestMethod] + public void ForEachAsync1() + { + var sum = 0; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + xs.ForEachAsync(x => sum += x).Wait(); + Assert.AreEqual(10, sum); + } + + [TestMethod] + public void ForEach1() + { + var sum = 0; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + xs.ForEach(x => sum += x); + Assert.AreEqual(10, sum); + } + + [TestMethod] + public void ForEachAsync2() + { + var sum = 0; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + xs.ForEach((x, i) => sum += x * i); + Assert.AreEqual(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum); + } + + [TestMethod] + public void ForEach2() + { + var sum = 0; + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + xs.ForEachAsync((x, i) => sum += x * i).Wait(); + Assert.AreEqual(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum); + } + + [TestMethod] + public void ForEachAsync3() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + AssertThrows(() => xs.ForEachAsync(x => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEach3() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + AssertThrows(() => xs.ForEach(x => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEachAsync4() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + AssertThrows(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEach4() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + + AssertThrows(() => xs.ForEach((x, i) => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEachAsync5() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + + AssertThrows(() => xs.ForEachAsync(x => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEach5() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + + AssertThrows(() => xs.ForEach(x => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEachAsync6() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + + AssertThrows(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ForEach6() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + + AssertThrows(() => xs.ForEach((x, i) => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Take_Null() + { + AssertThrows(() => AsyncEnumerable.Take(null, 5)); + AssertThrows(() => AsyncEnumerable.Take(AsyncEnumerable.Return(42), -1)); + } + + [TestMethod] + public void Take1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Take(2); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void Take2() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Take(10); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Take3() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Take(0); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Take4() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Take(2); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void TakeWhile_Null() + { + AssertThrows(() => AsyncEnumerable.TakeWhile(null, x => true)); + AssertThrows(() => AsyncEnumerable.TakeWhile(null, (x, i) => true)); + AssertThrows(() => AsyncEnumerable.TakeWhile(AsyncEnumerable.Return(42), default(Func))); + AssertThrows(() => AsyncEnumerable.TakeWhile(AsyncEnumerable.Return(42), default(Func))); + } + + [TestMethod] + public void TakeWhile1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile(x => x < 3); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void TakeWhile2() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile(x => false); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void TakeWhile3() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile(x => true); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void TakeWhile4() + { + var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile(x => x < 3); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void TakeWhile5() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void TakeWhile6() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile((x, i) => i < 2); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void TakeWhile7() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile((x, i) => false); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void TakeWhile8() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile((x, i) => true); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void TakeWhile9() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.TakeWhile((x, i) => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Skip_Null() + { + AssertThrows(() => AsyncEnumerable.Skip(null, 5)); + AssertThrows(() => AsyncEnumerable.Skip(AsyncEnumerable.Return(42), -1)); + } + + [TestMethod] + public void Skip1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Skip(2); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Skip2() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Skip(10); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Skip3() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.Skip(0); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Skip4() + { + var ex = new Exception("Bang"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Skip(2); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SkipWhile_Null() + { + AssertThrows(() => AsyncEnumerable.SkipWhile(null, x => true)); + AssertThrows(() => AsyncEnumerable.SkipWhile(null, (x, i) => true)); + AssertThrows(() => AsyncEnumerable.SkipWhile(AsyncEnumerable.Return(42), default(Func))); + AssertThrows(() => AsyncEnumerable.SkipWhile(AsyncEnumerable.Return(42), default(Func))); + } + + [TestMethod] + public void SkipWhile1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile(x => x < 3); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void SkipWhile2() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile(x => false); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void SkipWhile3() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile(x => true); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void SkipWhile4() + { + var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile(x => x < 3); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 3); + HasNext(e, 2); + HasNext(e, 1); + NoNext(e); + } + + [TestMethod] + public void SkipWhile5() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void SkipWhile6() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile((x, i) => i < 2); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void SkipWhile7() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile((x, i) => false); + + var e = ys.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void SkipWhile8() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile((x, i) => true); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void SkipWhile9() + { + var ex = new Exception("Bang"); + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); + var ys = xs.SkipWhile((x, i) => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void DefaultIfEmpty_Null() + { + AssertThrows(() => AsyncEnumerable.DefaultIfEmpty(null)); + AssertThrows(() => AsyncEnumerable.DefaultIfEmpty(null, 42)); + } + + [TestMethod] + public void DefaultIfEmpty1() + { + var xs = AsyncEnumerable.Empty().DefaultIfEmpty(); + + var e = xs.GetEnumerator(); + HasNext(e, 0); + NoNext(e); + } + + [TestMethod] + public void DefaultIfEmpty2() + { + var xs = AsyncEnumerable.Empty().DefaultIfEmpty(42); + + var e = xs.GetEnumerator(); + HasNext(e, 42); + NoNext(e); + } + + [TestMethod] + public void DefaultIfEmpty3() + { + var xs = AsyncEnumerable.Return(42).DefaultIfEmpty(); + + var e = xs.GetEnumerator(); + HasNext(e, 42); + NoNext(e); + } + + [TestMethod] + public void DefaultIfEmpty4() + { + var xs = AsyncEnumerable.Return(42).DefaultIfEmpty(24); + + var e = xs.GetEnumerator(); + HasNext(e, 42); + NoNext(e); + } + + [TestMethod] + public void DefaultIfEmpty5() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty(); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void DefaultIfEmpty6() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty(24); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void DefaultIfEmpty7() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex).DefaultIfEmpty(); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void DefaultIfEmpty8() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex).DefaultIfEmpty(24); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Distinct_Null() + { + AssertThrows(() => AsyncEnumerable.Distinct(null)); + AssertThrows(() => AsyncEnumerable.Distinct(null, new Eq())); + AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Distinct1() + { + var xs = new[] { 1, 2, 1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct(); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 5); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Distinct2() + { + var xs = new[] { 1, -2, -1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct(new Eq()); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, -2); + HasNext(e, 3); + HasNext(e, 5); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void Reverse_Null() + { + AssertThrows(() => AsyncEnumerable.Reverse(null)); + } + + [TestMethod] + public void Reverse1() + { + var xs = AsyncEnumerable.Empty(); + var ys = xs.Reverse(); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void Reverse2() + { + var xs = AsyncEnumerable.Return(42); + var ys = xs.Reverse(); + + var e = ys.GetEnumerator(); + HasNext(e, 42); + NoNext(e); + } + + [TestMethod] + public void Reverse3() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.Reverse(); + + var e = ys.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 2); + HasNext(e, 1); + NoNext(e); + } + + [TestMethod] + public void Reverse4() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.Reverse(); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void OrderBy_Null() + { + AssertThrows(() => AsyncEnumerable.OrderBy(null, x => x)); + AssertThrows(() => AsyncEnumerable.OrderBy(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.OrderBy(null, x => x, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.OrderBy(AsyncEnumerable.Return(42), null, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.OrderBy(AsyncEnumerable.Return(42), x => x, null)); + + AssertThrows(() => AsyncEnumerable.OrderByDescending(null, x => x)); + AssertThrows(() => AsyncEnumerable.OrderByDescending(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.OrderByDescending(null, x => x, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.OrderByDescending(AsyncEnumerable.Return(42), null, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.OrderByDescending(AsyncEnumerable.Return(42), x => x, null)); + + var xs = AsyncEnumerable.Return(42).OrderBy(x => x); + + AssertThrows(() => AsyncEnumerable.ThenBy(null, x => x)); + AssertThrows(() => AsyncEnumerable.ThenBy(xs, null)); + + AssertThrows(() => AsyncEnumerable.ThenBy(null, x => x, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.ThenBy(xs, null, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.ThenBy(xs, x => x, null)); + + AssertThrows(() => AsyncEnumerable.ThenByDescending(null, x => x)); + AssertThrows(() => AsyncEnumerable.ThenByDescending(xs, null)); + + AssertThrows(() => AsyncEnumerable.ThenByDescending(null, x => x, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.ThenByDescending(xs, null, Comparer.Default)); + AssertThrows(() => AsyncEnumerable.ThenByDescending(xs, x => x, null)); + } + + [TestMethod] + public void OrderBy1() + { + var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); + var ys = xs.OrderBy(x => x); + + var e = ys.GetEnumerator(); + for (int i = 0; i < 10; i++) + HasNext(e, i); + NoNext(e); + } + + [TestMethod] + public void OrderBy2() + { + var ex = new Exception("Bang!"); + var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); + var ys = xs.OrderBy(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ThenBy2() + { + var ex = new Exception("Bang!"); + var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); + var ys = xs.OrderBy(x => x).ThenBy(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void OrderByDescending1() + { + var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); + var ys = xs.OrderByDescending(x => x); + + var e = ys.GetEnumerator(); + for (int i = 9; i >= 0; i--) + HasNext(e, i); + NoNext(e); + } + + [TestMethod] + public void OrderByDescending2() + { + var ex = new Exception("Bang!"); + var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); + var ys = xs.OrderByDescending(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void ThenByDescending2() + { + var ex = new Exception("Bang!"); + var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); + var ys = xs.OrderBy(x => x).ThenByDescending(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void OrderByThenBy1() + { + var xs = new[] { + new { Name = "Bart", Age = 27 }, + new { Name = "John", Age = 62 }, + new { Name = "Eric", Age = 27 }, + new { Name = "Lisa", Age = 14 }, + new { Name = "Brad", Age = 27 }, + new { Name = "Lisa", Age = 23 }, + new { Name = "Eric", Age = 42 }, + }; + + var ys = xs.ToAsyncEnumerable(); + + var ress = xs.OrderBy(x => x.Name).ThenBy(x => x.Age); + var resa = ys.OrderBy(x => x.Name).ThenBy(x => x.Age); + + Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); + } + + [TestMethod] + public void OrderByThenBy2() + { + var xs = new[] { + new { Name = "Bart", Age = 27 }, + new { Name = "John", Age = 62 }, + new { Name = "Eric", Age = 27 }, + new { Name = "Lisa", Age = 14 }, + new { Name = "Brad", Age = 27 }, + new { Name = "Lisa", Age = 23 }, + new { Name = "Eric", Age = 42 }, + }; + + var ys = xs.ToAsyncEnumerable(); + + var ress = xs.OrderBy(x => x.Name).ThenByDescending(x => x.Age); + var resa = ys.OrderBy(x => x.Name).ThenByDescending(x => x.Age); + + Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); + } + + [TestMethod] + public void OrderByThenBy3() + { + var xs = new[] { + new { Name = "Bart", Age = 27 }, + new { Name = "John", Age = 62 }, + new { Name = "Eric", Age = 27 }, + new { Name = "Lisa", Age = 14 }, + new { Name = "Brad", Age = 27 }, + new { Name = "Lisa", Age = 23 }, + new { Name = "Eric", Age = 42 }, + }; + + var ys = xs.ToAsyncEnumerable(); + + var ress = xs.OrderByDescending(x => x.Name).ThenBy(x => x.Age); + var resa = ys.OrderByDescending(x => x.Name).ThenBy(x => x.Age); + + Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); + } + + [TestMethod] + public void OrderByThenBy4() + { + var xs = new[] { + new { Name = "Bart", Age = 27 }, + new { Name = "John", Age = 62 }, + new { Name = "Eric", Age = 27 }, + new { Name = "Lisa", Age = 14 }, + new { Name = "Brad", Age = 27 }, + new { Name = "Lisa", Age = 23 }, + new { Name = "Eric", Age = 42 }, + }; + + var ys = xs.ToAsyncEnumerable(); + + var ress = xs.OrderByDescending(x => x.Name).ThenByDescending(x => x.Age); + var resa = ys.OrderByDescending(x => x.Name).ThenByDescending(x => x.Age); + + Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); + } + + [TestMethod] + public void GroupBy_Null() + { + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(IEqualityComparer))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func), EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, default(IEqualityComparer))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, (x, ys) => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), (x, ys) => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func, int>))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, (x, ys) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), (x, ys) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func, int>), EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, (x, ys) => x, default(IEqualityComparer))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x, (x, ys) => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x, (x, ys) => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func), (x, ys) => x)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, default(Func, int>))); + + AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x, (x, ys) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x, (x, ys) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func), (x, ys) => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, default(Func, int>), EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, (x, ys) => x, default(IEqualityComparer))); + } + + [TestMethod] + public void GroupBy1() + { + var xs = new[] { + new { Name = "Bart", Age = 27 }, + new { Name = "John", Age = 62 }, + new { Name = "Eric", Age = 27 }, + new { Name = "Lisa", Age = 14 }, + new { Name = "Brad", Age = 27 }, + new { Name = "Lisa", Age = 23 }, + new { Name = "Eric", Age = 42 }, + }; + + var ys = xs.ToAsyncEnumerable(); + + var res = ys.GroupBy(x => x.Age / 10); + + var e = res.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + Assert.AreEqual(e.Current.Key, 2); + var g1 = e.Current.GetEnumerator(); + HasNext(g1, xs[0]); + HasNext(g1, xs[2]); + HasNext(g1, xs[4]); + HasNext(g1, xs[5]); + NoNext(g1); + + Assert.IsTrue(e.MoveNext().Result); + Assert.AreEqual(e.Current.Key, 6); + var g2 = e.Current.GetEnumerator(); + HasNext(g2, xs[1]); + NoNext(g2); + + Assert.IsTrue(e.MoveNext().Result); + Assert.AreEqual(e.Current.Key, 1); + var g3 = e.Current.GetEnumerator(); + HasNext(g3, xs[3]); + NoNext(g3); + + Assert.IsTrue(e.MoveNext().Result); + Assert.AreEqual(e.Current.Key, 4); + var g4 = e.Current.GetEnumerator(); + HasNext(g4, xs[6]); + NoNext(g4); + + NoNext(e); + } + + [TestMethod] + public void GroupBy2() + { + var xs = new[] { + new { Name = "Bart", Age = 27 }, + new { Name = "John", Age = 62 }, + new { Name = "Eric", Age = 27 }, + new { Name = "Lisa", Age = 14 }, + new { Name = "Brad", Age = 27 }, + new { Name = "Lisa", Age = 23 }, + new { Name = "Eric", Age = 42 }, + }; + + var ys = xs.ToAsyncEnumerable(); + + var res = ys.GroupBy(x => x.Age / 10); + + var e = res.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 2); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 6); + + Assert.IsTrue(e.MoveNext().Result); + var g3 = e.Current; + Assert.AreEqual(g3.Key, 1); + + Assert.IsTrue(e.MoveNext().Result); + var g4 = e.Current; + Assert.AreEqual(g4.Key, 4); + + NoNext(e); + + var g1e = g1.GetEnumerator(); + HasNext(g1e, xs[0]); + HasNext(g1e, xs[2]); + HasNext(g1e, xs[4]); + HasNext(g1e, xs[5]); + NoNext(g1e); + + var g2e = g2.GetEnumerator(); + HasNext(g2e, xs[1]); + NoNext(g2e); + + var g3e = g3.GetEnumerator(); + HasNext(g3e, xs[3]); + NoNext(g3e); + + var g4e = g4.GetEnumerator(); + HasNext(g4e, xs[6]); + NoNext(g4e); + } + + [TestMethod] + public void GroupBy3() + { + var xs = AsyncEnumerable.Empty(); + var ys = xs.GroupBy(x => x); + + var e = ys.GetEnumerator(); + NoNext(e); + } + + [TestMethod] + public void GroupBy4() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex); + var ys = xs.GroupBy(x => x); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupBy5() + { + var xs = GetXs().ToAsyncEnumerable(); + var ys = xs.GroupBy(x => x); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 42); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 42); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 43); + var g2e = g2.GetEnumerator(); + HasNext(g2e, 43); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + AssertThrows(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + AssertThrows(() => g2e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + } + + [TestMethod] + public void GroupBy6() + { + var xs = GetXs().ToAsyncEnumerable(); + var ys = xs.GroupBy(x => x); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 42); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 42); + AssertThrows(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); + } + + static IEnumerable GetXs() + { + yield return 42; + yield return 43; + throw new Exception("Bang!"); + } + + [TestMethod] + public void GroupBy7() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Return(42); + var ys = xs.GroupBy(x => { throw ex; }); + + var e = ys.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupBy8() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); + var ys = xs.GroupBy(x => { if (x == 3) throw ex; return x; }); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 1); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 1); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 2); + var g2e = g2.GetEnumerator(); + HasNext(g2e, 2); + + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + AssertThrows(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + AssertThrows(() => g2e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void GroupBy9() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x)); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 0); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 'a'); + HasNext(g1e, 'd'); + HasNext(g1e, 'g'); + HasNext(g1e, 'j'); + NoNext(g1e); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 1); + var g2e = g2.GetEnumerator(); + HasNext(g2e, 'b'); + HasNext(g2e, 'e'); + HasNext(g2e, 'h'); + NoNext(g2e); + + Assert.IsTrue(e.MoveNext().Result); + var g3 = e.Current; + Assert.AreEqual(g3.Key, 2); + var g3e = g3.GetEnumerator(); + HasNext(g3e, 'c'); + HasNext(g3e, 'f'); + HasNext(g3e, 'i'); + NoNext(g3e); + + NoNext(e); + } + + [TestMethod] + public void GroupBy10() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result); + + var e = ys.GetEnumerator(); + HasNext(e, "0 - adgj"); + HasNext(e, "1 - beh"); + HasNext(e, "2 - cfi"); + NoNext(e); + } + + [TestMethod] + public void GroupBy11() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x % 3, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result); + + var e = ys.GetEnumerator(); + HasNext(e, "0 - 0369"); + HasNext(e, "1 - 147"); + HasNext(e, "2 - 258"); + NoNext(e); + } + + [TestMethod] + public void GroupBy12() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, new EqMod(3)); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 0); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 0); + HasNext(g1e, 3); + HasNext(g1e, 6); + HasNext(g1e, 9); + NoNext(g1e); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 1); + var g2e = g2.GetEnumerator(); + HasNext(g2e, 1); + HasNext(g2e, 4); + HasNext(g2e, 7); + NoNext(g2e); + + Assert.IsTrue(e.MoveNext().Result); + var g3 = e.Current; + Assert.AreEqual(g3.Key, 2); + var g3e = g3.GetEnumerator(); + HasNext(g3e, 2); + HasNext(g3e, 5); + HasNext(g3e, 8); + NoNext(g3e); + + NoNext(e); + } + + [TestMethod] + public void GroupBy13() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 0); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 'a'); + HasNext(g1e, 'd'); + HasNext(g1e, 'g'); + HasNext(g1e, 'j'); + NoNext(g1e); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 1); + var g2e = g2.GetEnumerator(); + HasNext(g2e, 'b'); + HasNext(g2e, 'e'); + HasNext(g2e, 'h'); + NoNext(g2e); + + Assert.IsTrue(e.MoveNext().Result); + var g3 = e.Current; + Assert.AreEqual(g3.Key, 2); + var g3e = g3.GetEnumerator(); + HasNext(g3e, 'c'); + HasNext(g3e, 'f'); + HasNext(g3e, 'i'); + NoNext(g3e); + + NoNext(e); + } + + [TestMethod] + public void GroupBy14() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3)); + + var e = ys.GetEnumerator(); + HasNext(e, "0 - adgj"); + HasNext(e, "1 - beh"); + HasNext(e, "2 - cfi"); + NoNext(e); + } + + [TestMethod] + public void GroupBy15() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3)); + + var e = ys.GetEnumerator(); + HasNext(e, "0 - 0369"); + HasNext(e, "1 - 147"); + HasNext(e, "2 - 258"); + NoNext(e); + } + + [TestMethod] + public void GroupBy16() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 0); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 'a'); + HasNext(g1e, 'd'); + HasNext(g1e, 'g'); + HasNext(g1e, 'j'); + NoNext(g1e); + g1e.Dispose(); + + Assert.IsTrue(e.MoveNext().Result); + var g2 = e.Current; + Assert.AreEqual(g2.Key, 1); + var g2e = g2.GetEnumerator(); + HasNext(g2e, 'b'); + HasNext(g2e, 'e'); + HasNext(g2e, 'h'); + NoNext(g2e); + g2e.Dispose(); + + Assert.IsTrue(e.MoveNext().Result); + var g3 = e.Current; + Assert.AreEqual(g3.Key, 2); + var g3e = g3.GetEnumerator(); + HasNext(g3e, 'c'); + HasNext(g3e, 'f'); + HasNext(g3e, 'i'); + NoNext(g3e); + g3e.Dispose(); + + NoNext(e); + + e.Dispose(); + } + + [TestMethod] + public void GroupBy17() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); + + var e = ys.GetEnumerator(); + e.Dispose(); + + Assert.IsFalse(e.MoveNext().Result); + } + + [TestMethod] + public void GroupBy18() + { + var xs = AsyncEnumerable.Range(0, 10); + var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); + + var e = ys.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + var g1 = e.Current; + Assert.AreEqual(g1.Key, 0); + var g1e = g1.GetEnumerator(); + HasNext(g1e, 'a'); + + e.Dispose(); + + HasNext(g1e, 'd'); + HasNext(g1e, 'g'); + HasNext(g1e, 'j'); + NoNext(g1e); + g1e.Dispose(); + + Assert.IsFalse(e.MoveNext().Result); + } + + class EqMod : IEqualityComparer + { + private readonly int _d; + + public EqMod(int d) + { + _d = d; + } + + public bool Equals(int x, int y) + { + return EqualityComparer.Default.Equals(x % _d, y % _d); + } + + public int GetHashCode(int obj) + { + return EqualityComparer.Default.GetHashCode(obj % _d); + } + } + + [TestMethod] + public void AsAsyncEnumerable_Null() + { + AssertThrows(() => AsyncEnumerable.AsAsyncEnumerable(null)); + } + + [TestMethod] + public void AsAsyncEnumerable1() + { + var xs = AsyncEnumerable.Return(42); + var ys = xs.AsAsyncEnumerable(); + + Assert.AreNotSame(xs, ys); + + var e = xs.GetEnumerator(); + HasNext(e, 42); + NoNext(e); + } + + [TestMethod] + public void RepeatSeq_Null() + { + AssertThrows(() => AsyncEnumerable.Repeat(default(IAsyncEnumerable))); + AssertThrows(() => AsyncEnumerable.Repeat(default(IAsyncEnumerable), 3)); + AssertThrows(() => AsyncEnumerable.Repeat(AsyncEnumerable.Return(42), -1)); + } + + [TestMethod] + public void RepeatSeq1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat(); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + } + + [TestMethod] + public void RepeatSeq2() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat(3); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + NoNext(e); + } + + [TestMethod] + public void RepeatSeq3() + { + var i = 0; + var xs = RepeatXs(() => i++).ToAsyncEnumerable().Repeat(3); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + + Assert.AreEqual(3, i); + } + + static IEnumerable RepeatXs(Action started) + { + started(); + + yield return 1; + yield return 2; + } + + [TestMethod] + public void RepeatSeq4() + { + var xs = new FailRepeat().ToAsyncEnumerable().Repeat(); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException); + } + + [TestMethod] + public void RepeatSeq5() + { + var xs = new FailRepeat().ToAsyncEnumerable().Repeat(3); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException); + } + + class FailRepeat : IEnumerable + { + public IEnumerator GetEnumerator() + { + throw new NotImplementedException(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + throw new NotImplementedException(); + } + } + + [TestMethod] + public void IgnoreElements_Null() + { + AssertThrows(() => AsyncEnumerable.IgnoreElements(default(IAsyncEnumerable))); + } + + [TestMethod] + public void IgnoreElements1() + { + var xs = AsyncEnumerable.Empty().IgnoreElements(); + + var e = xs.GetEnumerator(); + NoNext(e); + + AssertThrows(() => { var ignored = e.Current; }); + } + + [TestMethod] + public void IgnoreElements2() + { + var xs = AsyncEnumerable.Return(42).IgnoreElements(); + + var e = xs.GetEnumerator(); + NoNext(e); + + AssertThrows(() => { var ignored = e.Current; }); + } + + [TestMethod] + public void IgnoreElements3() + { + var xs = AsyncEnumerable.Range(0, 10).IgnoreElements(); + + var e = xs.GetEnumerator(); + NoNext(e); + + AssertThrows(() => { var ignored = e.Current; }); + } + + [TestMethod] + public void IgnoreElements4() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex).IgnoreElements(); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void StartWith_Null() + { + AssertThrows(() => AsyncEnumerable.StartWith(default(IAsyncEnumerable), new[] { 1 })); + AssertThrows(() => AsyncEnumerable.StartWith(AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void StartWith1() + { + var xs = AsyncEnumerable.Empty().StartWith(1, 2); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void StartWith2() + { + var xs = AsyncEnumerable.Return(0).StartWith(1, 2); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 0); + NoNext(e); + } + + [TestMethod] + public void StartWith3() + { + var ex = new Exception("Bang!"); + var xs = AsyncEnumerable.Throw(ex).StartWith(1, 2); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Buffer_Null() + { + AssertThrows(() => AsyncEnumerable.Buffer(default(IAsyncEnumerable), 1)); + AssertThrows(() => AsyncEnumerable.Buffer(default(IAsyncEnumerable), 1, 1)); + + AssertThrows(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), -1)); + AssertThrows(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), -1, 1)); + AssertThrows(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), 1, -1)); + } + + [TestMethod] + public void Buffer1() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(2); + + var e = xs.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 1, 2 })); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 3, 4 })); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 5 })); + + Assert.IsFalse(e.MoveNext().Result); + } + + [TestMethod] + public void Buffer2() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(3, 2); + + var e = xs.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 1, 2, 3 })); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 3, 4, 5 })); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 5 })); + + Assert.IsFalse(e.MoveNext().Result); + } + + [TestMethod] + public void Buffer3() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(2, 3); + + var e = xs.GetEnumerator(); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 1, 2 })); + + Assert.IsTrue(e.MoveNext().Result); + Assert.IsTrue(e.Current.SequenceEqual(new[] { 4, 5 })); + + Assert.IsFalse(e.MoveNext().Result); + } + + [TestMethod] + public void DistinctUntilChanged_Null() + { + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable))); + + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable), EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(IEqualityComparer))); + + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(Func))); + + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable), x => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(Func), EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), x => x, default(IEqualityComparer))); + } + + [TestMethod] + public void DistinctUntilChanged1() + { + var xs = new[] { 1, 2, 2, 3, 4, 4, 4, 4, 5, 6, 6, 7, 3, 2, 2, 1, 1 }.ToAsyncEnumerable().DistinctUntilChanged(); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + HasNext(e, 5); + HasNext(e, 6); + HasNext(e, 7); + HasNext(e, 3); + HasNext(e, 2); + HasNext(e, 1); + NoNext(e); + } + + [TestMethod] + public void DistinctUntilChanged2() + { + var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => (x + 1) / 2); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 3); + HasNext(e, 5); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void DistinctUntilChanged3() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => { if (x == 4) throw ex; return x; }); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Expand_Null() + { + AssertThrows(() => AsyncEnumerable.Expand(default(IAsyncEnumerable), x => null)); + AssertThrows(() => AsyncEnumerable.Expand(AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Expand1() + { + var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => AsyncEnumerable.Return(x - 1).Repeat(x - 1)); + + var e = xs.GetEnumerator(); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 2); + HasNext(e, 1); + HasNext(e, 1); + NoNext(e); + } + + [TestMethod] + public void Expand2() + { + var ex = new Exception("Bang!"); + var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => { throw ex; }); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Expand3() + { + var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => null); + + var e = xs.GetEnumerator(); + HasNext(e, 2); + HasNext(e, 3); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NullReferenceException); + } + + [TestMethod] + public void Scan_Null() + { + AssertThrows(() => AsyncEnumerable.Scan(default(IAsyncEnumerable), 3, (x, y) => x + y)); + AssertThrows(() => AsyncEnumerable.Scan(AsyncEnumerable.Return(42), 3, null)); + + AssertThrows(() => AsyncEnumerable.Scan(default(IAsyncEnumerable), (x, y) => x + y)); + AssertThrows(() => AsyncEnumerable.Scan(AsyncEnumerable.Return(42), null)); + } + + [TestMethod] + public void Scan1() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => x + y); + + var e = xs.GetEnumerator(); + HasNext(e, 9); + HasNext(e, 11); + HasNext(e, 14); + NoNext(e); + } + + [TestMethod] + public void Scan2() + { + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => x + y); + + var e = xs.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 6); + NoNext(e); + } + + [TestMethod] + public void Scan3() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => { throw ex; }); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void Scan4() + { + var ex = new Exception("Bang!"); + var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => { throw ex; }); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); + } + + [TestMethod] + public void DistinctKey_Null() + { + AssertThrows(() => AsyncEnumerable.Distinct(default(IAsyncEnumerable), x => x)); + AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null)); + + AssertThrows(() => AsyncEnumerable.Distinct(default(IAsyncEnumerable), x => x, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null, EqualityComparer.Default)); + AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), x => x, null)); + } + + [TestMethod] + public void DistinctKey1() + { + var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Distinct(x => x / 2); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void TakeLast_Null() + { + AssertThrows(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable), 5)); + AssertThrows(() => AsyncEnumerable.TakeLast(AsyncEnumerable.Return(42), -1)); + } + + [TestMethod] + public void TakeLast1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2); + + var e = xs.GetEnumerator(); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void TakeLast2() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(5); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + HasNext(e, 4); + NoNext(e); + } + + [TestMethod] + public void SkipLast_Null() + { + AssertThrows(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable), 5)); + AssertThrows(() => AsyncEnumerable.SkipLast(AsyncEnumerable.Return(42), -1)); + } + + [TestMethod] + public void SkipLast1() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2); + + var e = xs.GetEnumerator(); + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + } + + [TestMethod] + public void SkipLast2() + { + var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(5); + + var e = xs.GetEnumerator(); + NoNext(e); + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.cs b/Ix/Tests/AsyncTests.cs new file mode 100644 index 0000000..9279bb7 --- /dev/null +++ b/Ix/Tests/AsyncTests.cs @@ -0,0 +1,54 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if DESKTOPCLR40 + +using System; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + [TestClass] + public partial class AsyncTests + { + public void AssertThrows(Action a) + where E : Exception + { + try + { + a(); + Assert.Fail(); + } + catch (E) + { + } + } + + public void AssertThrows(Action a, Func assert) + where E : Exception + { + try + { + a(); + Assert.Fail(); + } + catch (E e) + { + Assert.IsTrue(assert(e)); + } + } + + public void NoNext(IAsyncEnumerator e) + { + Assert.IsFalse(e.MoveNext().Result); + } + + public void HasNext(IAsyncEnumerator e, T value) + { + Assert.IsTrue(e.MoveNext().Result); + Assert.AreEqual(value, e.Current); + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/Properties/AppManifest.xml b/Ix/Tests/Properties/AppManifest.xml new file mode 100644 index 0000000..71b66f8 --- /dev/null +++ b/Ix/Tests/Properties/AppManifest.xml @@ -0,0 +1,7 @@ + + + + + diff --git a/Ix/Tests/Properties/AssemblyInfo.cs b/Ix/Tests/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..6536c5c --- /dev/null +++ b/Ix/Tests/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Tests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Microsoft")] +[assembly: AssemblyProduct("Tests")] +[assembly: AssemblyCopyright("Copyright © Microsoft 2011")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("aec256c2-1e0e-48d7-a312-7184dc67b1f0")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +//[assembly: AssemblyVersion("1.0.0.0")] +//[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Ix/Tests/Tests.Aggregates.cs b/Ix/Tests/Tests.Aggregates.cs new file mode 100644 index 0000000..8fd8cee --- /dev/null +++ b/Ix/Tests/Tests.Aggregates.cs @@ -0,0 +1,118 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void IsEmtpy_Arguments() + { + AssertThrows(() => EnumerableEx.IsEmpty(null)); + } + + [TestMethod] + public void IsEmpty_Empty() + { + Assert.IsTrue(Enumerable.Empty().IsEmpty()); + } + + [TestMethod] + public void IsEmpty_NonEmpty() + { + Assert.IsFalse(new[] { 1 }.IsEmpty()); + } + + [TestMethod] + public void Min_Arguments() + { + AssertThrows(() => EnumerableEx.Min(null, Comparer.Default)); + AssertThrows(() => EnumerableEx.Min(new[] { 1 }, null)); + } + + [TestMethod] + public void Min() + { + Assert.AreEqual(3, new[] { 5, 3, 7 }.Min(new Mod3Comparer())); + } + + class Mod3Comparer : IComparer + { + public int Compare(int x, int y) + { + return Comparer.Default.Compare(x % 3, y % 3); + } + } + + [TestMethod] + public void MinBy_Arguments() + { + AssertThrows(() => EnumerableEx.MinBy(null, (int x) => x)); + AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, default(Func))); + AssertThrows(() => EnumerableEx.MinBy(null, (int x) => x, Comparer.Default)); + AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, default(Func), Comparer.Default)); + AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, (int x) => x, null)); + } + + [TestMethod] + public void MinBy() + { + var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MinBy(x => x % 3); + Assert.IsTrue(res.SequenceEqual(new[] { 0, 3, 6 })); + } + + [TestMethod] + public void MinBy_Empty() + { + AssertThrows(() => Enumerable.Empty().MinBy(x => x)); + } + + [TestMethod] + public void Max_Arguments() + { + AssertThrows(() => EnumerableEx.Max(null, Comparer.Default)); + AssertThrows(() => EnumerableEx.Max(new[] { 1 }, null)); + } + + [TestMethod] + public void Max() + { + Assert.AreEqual(5, new[] { 2, 5, 3, 7 }.Max(new Mod7Comparer())); + } + + class Mod7Comparer : IComparer + { + public int Compare(int x, int y) + { + return Comparer.Default.Compare(x % 7, y % 7); + } + } + + [TestMethod] + public void MaxBy_Arguments() + { + AssertThrows(() => EnumerableEx.MaxBy(null, (int x) => x)); + AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, default(Func))); + AssertThrows(() => EnumerableEx.MaxBy(null, (int x) => x, Comparer.Default)); + AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, default(Func), Comparer.Default)); + AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, (int x) => x, null)); + } + + [TestMethod] + public void MaxBy() + { + var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MaxBy(x => x % 3); + Assert.IsTrue(res.SequenceEqual(new[] { 2, 5, 2 })); + } + + [TestMethod] + public void MaxBy_Empty() + { + AssertThrows(() => Enumerable.Empty().MaxBy(x => x)); + } + } +} diff --git a/Ix/Tests/Tests.Buffering.cs b/Ix/Tests/Tests.Buffering.cs new file mode 100644 index 0000000..0f6e81c --- /dev/null +++ b/Ix/Tests/Tests.Buffering.cs @@ -0,0 +1,625 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Collections; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void Share_Arguments() + { + AssertThrows(() => EnumerableEx.Share(null)); + } + + [TestMethod] + public void Share1() + { + var rng = Enumerable.Range(0, 5).Share(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + HasNext(e1, 3); + HasNext(e1, 4); + NoNext(e1); + } + + [TestMethod] + public void Share2() + { + var rng = Enumerable.Range(0, 5).Share(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e2, 1); + HasNext(e1, 2); + HasNext(e2, 3); + HasNext(e1, 4); + NoNext(e2); + NoNext(e1); + } + + [TestMethod] + public void Share3() + { + var rng = Enumerable.Range(0, 5).Share(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + var e2 = rng.GetEnumerator(); + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e2); + NoNext(e1); + } + + [TestMethod] + public void Share4() + { + var rng = Enumerable.Range(0, 5).Share(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + e1.Dispose(); + Assert.IsFalse(e1.MoveNext()); + } + + [TestMethod] + public void Share5() + { + var rng = Enumerable.Range(0, 5).Share(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + rng.Dispose(); + AssertThrows(() => e1.MoveNext()); + AssertThrows(() => rng.GetEnumerator()); + AssertThrows(() => ((IEnumerable)rng).GetEnumerator()); + } + + [TestMethod] + public void Share6() + { + var rng = Enumerable.Range(0, 5).Share(); + + var e1 = ((IEnumerable)rng).GetEnumerator(); + Assert.IsTrue(e1.MoveNext()); + Assert.AreEqual(0, (int)e1.Current); + } + + [TestMethod] + public void Publish_Arguments() + { + AssertThrows(() => EnumerableEx.Publish(null)); + } + + [TestMethod] + public void Publish0() + { + var n = 0; + var rng = Tick(i => n += i).Publish(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + + HasNext(e1, 0); + Assert.AreEqual(0, n); + + HasNext(e1, 1); + Assert.AreEqual(1, n); + + HasNext(e1, 2); + Assert.AreEqual(3, n); + HasNext(e2, 0); + Assert.AreEqual(3, n); + + HasNext(e1, 3); + Assert.AreEqual(6, n); + HasNext(e2, 1); + Assert.AreEqual(6, n); + + HasNext(e2, 2); + Assert.AreEqual(6, n); + HasNext(e2, 3); + Assert.AreEqual(6, n); + + HasNext(e2, 4); + Assert.AreEqual(10, n); + HasNext(e1, 4); + Assert.AreEqual(10, n); + } + + static IEnumerable Tick(Action t) + { + var i = 0; + while (true) + { + t(i); + yield return i++; + } + } + + [TestMethod] + public void Publish1() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + HasNext(e1, 3); + HasNext(e1, 4); + NoNext(e1); + } + + [TestMethod] + public void Publish2() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e2, 0); + HasNext(e1, 1); + HasNext(e2, 1); + HasNext(e1, 2); + HasNext(e2, 2); + HasNext(e1, 3); + HasNext(e2, 3); + HasNext(e1, 4); + HasNext(e2, 4); + NoNext(e1); + NoNext(e2); + } + + [TestMethod] + public void Publish3() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + HasNext(e1, 3); + HasNext(e1, 4); + HasNext(e2, 0); + HasNext(e2, 1); + HasNext(e2, 2); + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e1); + NoNext(e2); + } + + [TestMethod] + public void Publish4() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + var e2 = rng.GetEnumerator(); + HasNext(e1, 3); + HasNext(e1, 4); + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e1); + NoNext(e2); + } + + [TestMethod] + public void Publish5() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + e1.Dispose(); + + var e2 = rng.GetEnumerator(); + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e2); + } + + [TestMethod] + public void Publish6() + { + var ex = new MyException(); + var rng = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw(ex)).Publish(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + AssertThrows(() => e1.MoveNext()); + + HasNext(e2, 0); + HasNext(e2, 1); + AssertThrows(() => e2.MoveNext()); + } + + class MyException : Exception + { + } + + [TestMethod] + public void Publish7() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + var e2 = rng.GetEnumerator(); + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e2); + + HasNext(e1, 3); + HasNext(e1, 4); + NoNext(e2); + + var e3 = rng.GetEnumerator(); + NoNext(e3); + } + + [TestMethod] + public void Publish8() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + rng.Dispose(); + AssertThrows(() => e1.MoveNext()); + AssertThrows(() => rng.GetEnumerator()); + AssertThrows(() => ((IEnumerable)rng).GetEnumerator()); + } + + [TestMethod] + public void Publish9() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = ((IEnumerable)rng).GetEnumerator(); + Assert.IsTrue(e1.MoveNext()); + Assert.AreEqual(0, (int)e1.Current); + } + + [TestMethod] + public void Publish10() + { + var rnd = Rand().Take(1000).Publish(); + Assert.IsTrue(rnd.Zip(rnd, (l, r) => l == r).All(x => x)); + } + + [TestMethod] + public void Memoize_Arguments() + { + AssertThrows(() => EnumerableEx.Memoize(null)); + } + + [TestMethod] + public void MemoizeLimited_Arguments() + { + AssertThrows(() => EnumerableEx.Memoize(null, 2)); + AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 0)); + AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, -1)); + } + + [TestMethod] + public void Memoize0() + { + var n = 0; + var rng = Tick(i => n += i).Memoize(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + + HasNext(e1, 0); + Assert.AreEqual(0, n); + + HasNext(e1, 1); + Assert.AreEqual(1, n); + + HasNext(e1, 2); + Assert.AreEqual(3, n); + HasNext(e2, 0); + Assert.AreEqual(3, n); + + HasNext(e1, 3); + Assert.AreEqual(6, n); + HasNext(e2, 1); + Assert.AreEqual(6, n); + + HasNext(e2, 2); + Assert.AreEqual(6, n); + HasNext(e2, 3); + Assert.AreEqual(6, n); + + HasNext(e2, 4); + Assert.AreEqual(10, n); + HasNext(e1, 4); + Assert.AreEqual(10, n); + } + + [TestMethod] + public void Publish11() + { + var rng = Enumerable.Range(0, 5).Publish(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + e1.Dispose(); + + HasNext(e2, 0); + HasNext(e2, 1); + e2.Dispose(); + + var e3 = rng.GetEnumerator(); + HasNext(e3, 3); + HasNext(e3, 4); + NoNext(e3); + } + + [TestMethod] + public void Memoize1() + { + var rng = Enumerable.Range(0, 5).Memoize(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + HasNext(e1, 3); + HasNext(e1, 4); + NoNext(e1); + } + + [TestMethod] + public void Memoize2() + { + var rng = Enumerable.Range(0, 5).Memoize(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + HasNext(e1, 3); + HasNext(e1, 4); + NoNext(e1); + + var e2 = rng.GetEnumerator(); + HasNext(e2, 0); + HasNext(e2, 1); + HasNext(e2, 2); + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e2); + } + + [TestMethod] + public void Memoize3() + { + var rng = Enumerable.Range(0, 5).Memoize(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + var e2 = rng.GetEnumerator(); + HasNext(e1, 3); + HasNext(e2, 0); + HasNext(e2, 1); + HasNext(e1, 4); + HasNext(e2, 2); + NoNext(e1); + + HasNext(e2, 3); + HasNext(e2, 4); + NoNext(e2); + } + + [TestMethod] + public void Memoize4() + { + var rng = Enumerable.Range(0, 5).Memoize(2); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + var e2 = rng.GetEnumerator(); + HasNext(e2, 0); + HasNext(e2, 1); + HasNext(e2, 2); + + var e3 = rng.GetEnumerator(); + AssertThrows(() => e3.MoveNext()); + } + + [TestMethod] + public void Memoize6() + { + var ex = new MyException(); + var rng = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw(ex)).Memoize(); + + var e1 = rng.GetEnumerator(); + var e2 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + AssertThrows(() => e1.MoveNext()); + + HasNext(e2, 0); + HasNext(e2, 1); + AssertThrows(() => e2.MoveNext()); + } + + [TestMethod] + public void Memoize7() + { + var rng = Enumerable.Range(0, 5).Memoize(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + e1.Dispose(); + + var e2 = rng.GetEnumerator(); + HasNext(e2, 0); + HasNext(e2, 1); + e2.Dispose(); + + var e3 = rng.GetEnumerator(); + HasNext(e3, 0); + HasNext(e3, 1); + HasNext(e3, 2); + HasNext(e3, 3); + HasNext(e3, 4); + NoNext(e3); + } + + [TestMethod] + public void Memoize8() + { + var rng = Enumerable.Range(0, 5).Memoize(); + + var e1 = rng.GetEnumerator(); + HasNext(e1, 0); + HasNext(e1, 1); + HasNext(e1, 2); + + rng.Dispose(); + AssertThrows(() => e1.MoveNext()); + AssertThrows(() => rng.GetEnumerator()); + AssertThrows(() => ((IEnumerable)rng).GetEnumerator()); + } + + [TestMethod] + public void Memoize9() + { + var rng = Enumerable.Range(0, 5).Memoize(); + + var e1 = ((IEnumerable)rng).GetEnumerator(); + Assert.IsTrue(e1.MoveNext()); + Assert.AreEqual(0, (int)e1.Current); + } + + [TestMethod] + public void Memoize10() + { + var rnd = Rand().Take(1000).Memoize(); + Assert.IsTrue(rnd.Zip(rnd, (l, r) => l == r).All(x => x)); + } + + static Random s_rand = new Random(); + + static IEnumerable Rand() + { + while (true) + yield return s_rand.Next(); + } + + [TestMethod] + public void ShareLambda_Arguments() + { + AssertThrows(() => EnumerableEx.Share(null, xs => xs)); + AssertThrows(() => EnumerableEx.Share(new[] { 1 }, null)); + } + + [TestMethod] + public void ShareLambda() + { + var n = 0; + var res = Enumerable.Range(0, 10).Do(_ => n++).Share(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); + Assert.IsTrue(res.SequenceEqual(new[] { 0 + 1, 2 + 3, 4 + 5, 6 + 7 })); + Assert.AreEqual(8, n); + } + + [TestMethod] + public void PublishLambda_Arguments() + { + AssertThrows(() => EnumerableEx.Publish(null, xs => xs)); + AssertThrows(() => EnumerableEx.Publish(new[] { 1 }, null)); + } + + [TestMethod] + public void PublishLambda() + { + var n = 0; + var res = Enumerable.Range(0, 10).Do(_ => n++).Publish(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2))); + Assert.AreEqual(4, n); + } + + [TestMethod] + public void MemoizeLambda_Arguments() + { + AssertThrows(() => EnumerableEx.Memoize(null, xs => xs)); + AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, null)); + } + + [TestMethod] + public void MemoizeLambda() + { + var n = 0; + var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2))); + Assert.AreEqual(4, n); + } + + [TestMethod] + public void MemoizeLimitedLambda_Arguments() + { + AssertThrows(() => EnumerableEx.Memoize(null, 2, xs => xs)); + AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 2, null)); + AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 0, xs => xs)); + AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, -1, xs => xs)); + } + + [TestMethod] + public void MemoizeLimitedLambda() + { + var n = 0; + var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(2, xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2))); + Assert.AreEqual(4, n); + } + } +} diff --git a/Ix/Tests/Tests.Creation.cs b/Ix/Tests/Tests.Creation.cs new file mode 100644 index 0000000..81fee03 --- /dev/null +++ b/Ix/Tests/Tests.Creation.cs @@ -0,0 +1,224 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Collections; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void Create_Arguments() + { + AssertThrows(() => EnumerableEx.Create(default(Func>))); + } + + [TestMethod] + public void Create1() + { + var hot = false; + var res = EnumerableEx.Create(() => + { + hot = true; + return MyEnumerator(); + }); + + Assert.IsFalse(hot); + + var e = res.GetEnumerator(); + Assert.IsTrue(hot); + + HasNext(e, 1); + HasNext(e, 2); + NoNext(e); + + hot = false; + var f = ((IEnumerable)res).GetEnumerator(); + Assert.IsTrue(hot); + } + + private static IEnumerator MyEnumerator() + { + yield return 1; + yield return 2; + } + + [TestMethod] + public void Return() + { + Assert.AreEqual(42, EnumerableEx.Return(42).Single()); + } + + [TestMethod] + public void Throw_Arguments() + { + AssertThrows(() => EnumerableEx.Throw(null)); + } + + [TestMethod] + public void Throw() + { + var ex = new MyException(); + var xs = EnumerableEx.Throw(ex); + + var e = xs.GetEnumerator(); + AssertThrows(() => e.MoveNext()); + } + + [TestMethod] + public void Defer_Arguments() + { + AssertThrows(() => EnumerableEx.Defer(null)); + } + + [TestMethod] + public void Defer1() + { + var i = 0; + var n = 5; + var xs = EnumerableEx.Defer(() => + { + i++; + return Enumerable.Range(0, n); + }); + + Assert.AreEqual(0, i); + + Assert.IsTrue(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n))); + Assert.AreEqual(1, i); + + n = 3; + Assert.IsTrue(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n))); + Assert.AreEqual(2, i); + } + + [TestMethod] + public void Defer2() + { + var xs = EnumerableEx.Defer(() => + { + throw new MyException(); + }); + + AssertThrows(() => xs.GetEnumerator().MoveNext()); + } + + [TestMethod] + public void Generate_Arguments() + { + AssertThrows(() => EnumerableEx.Generate(0, null, _ => _, _ => _)); + AssertThrows(() => EnumerableEx.Generate(0, _ => true, null, _ => _)); + AssertThrows(() => EnumerableEx.Generate(0, _ => true, _ => _, null)); + } + + [TestMethod] + public void Generate() + { + var res = EnumerableEx.Generate(0, x => x < 5, x => x + 1, x => x * x).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0, 1, 4, 9, 16 })); + } + + [TestMethod] + public void Using_Arguments() + { + AssertThrows(() => EnumerableEx.Using(null, d => new[] { 1 })); + AssertThrows(() => EnumerableEx.Using(() => new MyDisposable(), null)); + } + + [TestMethod] + public void Using1() + { + var d = default(MyDisposable); + + var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => new[] { 1 }); + Assert.IsNull(d); + + var d1 = default(MyDisposable); + xs.ForEach(_ => { d1 = d; Assert.IsNotNull(d1); Assert.IsFalse(d1.Done); }); + Assert.IsTrue(d1.Done); + + var d2 = default(MyDisposable); + xs.ForEach(_ => { d2 = d; Assert.IsNotNull(d2); Assert.IsFalse(d2.Done); }); + Assert.IsTrue(d2.Done); + + Assert.AreNotSame(d1, d2); + } + + [TestMethod] + public void Using2() + { + var d = default(MyDisposable); + + var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => EnumerableEx.Throw(new MyException())); + Assert.IsNull(d); + + AssertThrows(() => xs.ForEach(_ => { })); + Assert.IsTrue(d.Done); + } + + [TestMethod] + public void Using3() + { + var d = default(MyDisposable); + + var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => { throw new MyException(); }); + Assert.IsNull(d); + + AssertThrows(() => xs.ForEach(_ => { })); + Assert.IsTrue(d.Done); + } + + class MyDisposable : IDisposable + { + public bool Done; + + public void Dispose() + { + Done = true; + } + } + + [TestMethod] + public void RepeatElementInfinite() + { + var xs = EnumerableEx.Repeat(42).Take(1000); + Assert.IsTrue(xs.All(x => x == 42)); + Assert.IsTrue(xs.Count() == 1000); + } + + [TestMethod] + public void RepeatSequence_Arguments() + { + AssertThrows(() => EnumerableEx.Repeat(null)); + AssertThrows(() => EnumerableEx.Repeat(null, 5)); + AssertThrows(() => EnumerableEx.Repeat(new[] { 1 }, -1)); + } + + [TestMethod] + public void RepeatSequence1() + { + var i = 0; + var xs = new[] { 1, 2 }.Do(_ => i++).Repeat(); + + var res = xs.Take(10).ToList(); + Assert.AreEqual(10, res.Count); + Assert.IsTrue(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3)); + Assert.AreEqual(10, i); + } + + [TestMethod] + public void RepeatSequence2() + { + var i = 0; + var xs = new[] { 1, 2 }.Do(_ => i++).Repeat(5); + + var res = xs.ToList(); + Assert.AreEqual(10, res.Count); + Assert.IsTrue(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3)); + Assert.AreEqual(10, i); + } + } +} diff --git a/Ix/Tests/Tests.Exceptions.cs b/Ix/Tests/Tests.Exceptions.cs new file mode 100644 index 0000000..38cabe4 --- /dev/null +++ b/Ix/Tests/Tests.Exceptions.cs @@ -0,0 +1,311 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void Catch_Arguments() + { + AssertThrows(() => EnumerableEx.Catch(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.Catch(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Catch(default(IEnumerable[]))); + AssertThrows(() => EnumerableEx.Catch(default(IEnumerable>))); + AssertThrows(() => EnumerableEx.Catch(null, ex => new[] { 1 })); + AssertThrows(() => EnumerableEx.Catch(new[] { 1 }, null)); + } + + [TestMethod] + public void Catch1() + { + var ex = new MyException(); + var res = EnumerableEx.Throw(ex).Catch(e => { Assert.AreSame(ex, e); return new[] { 42 }; }).Single(); + Assert.AreEqual(42, res); + } + + [TestMethod] + public void Catch2() + { + var ex = new MyException(); + var res = EnumerableEx.Throw(ex).Catch(e => { Assert.AreSame(ex, e); return new[] { 42 }; }).Single(); + Assert.AreEqual(42, res); + } + + [TestMethod] + public void Catch3() + { + var ex = new MyException(); + AssertThrows(() => + { + EnumerableEx.Throw(ex).Catch(e => { Assert.Fail(); return new[] { 42 }; }).Single(); + }); + } + + [TestMethod] + public void Catch4() + { + var xs = Enumerable.Range(0, 10); + var res = xs.Catch(e => { Assert.Fail(); return new[] { 42 }; }); + Assert.IsTrue(xs.SequenceEqual(res)); + } + + [TestMethod] + public void Catch5() + { + var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) }; + var res = EnumerableEx.Catch(xss); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5))); + } + + [TestMethod] + public void Catch6() + { + var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) }; + var res = xss.Catch(); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5))); + } + + [TestMethod] + public void Catch7() + { + var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) }; + var res = xss[0].Catch(xss[1]); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5))); + } + + [TestMethod] + public void Catch8() + { + var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw(new MyException())), Enumerable.Range(5, 5) }; + var res = EnumerableEx.Catch(xss); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); + } + + [TestMethod] + public void Catch9() + { + var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw(new MyException())), Enumerable.Range(5, 5) }; + var res = xss.Catch(); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); + } + + [TestMethod] + public void Catch10() + { + var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw(new MyException())), Enumerable.Range(5, 5) }; + var res = xss[0].Catch(xss[1]); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); + } + + [TestMethod] + public void Catch11() + { + var e1 = new MyException(); + var ex1 = EnumerableEx.Throw(e1); + + var e2 = new MyException(); + var ex2 = EnumerableEx.Throw(e2); + + var e3 = new MyException(); + var ex3 = EnumerableEx.Throw(e3); + + var xss = new[] { Enumerable.Range(0, 2).Concat(ex1), Enumerable.Range(2, 2).Concat(ex2), ex3 }; + var res = xss.Catch(); + + var e = res.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 1); + HasNext(e, 2); + HasNext(e, 3); + AssertThrows(() => e.MoveNext(), ex => ex == e3); + } + + [TestMethod] + public void Finally_Arguments() + { + AssertThrows(() => EnumerableEx.Finally(null, () => { })); + AssertThrows(() => EnumerableEx.Finally(new[] { 1 }, null)); + } + + [TestMethod] + public void Finally1() + { + var done = false; + + var xs = Enumerable.Range(0, 2).Finally(() => done = true); + Assert.IsFalse(done); + + var e = xs.GetEnumerator(); + Assert.IsFalse(done); + + HasNext(e, 0); + Assert.IsFalse(done); + + HasNext(e, 1); + Assert.IsFalse(done); + + NoNext(e); + Assert.IsTrue(done); + } + + [TestMethod] + public void Finally2() + { + var done = false; + + var xs = Enumerable.Range(0, 2).Finally(() => done = true); + Assert.IsFalse(done); + + var e = xs.GetEnumerator(); + Assert.IsFalse(done); + + HasNext(e, 0); + Assert.IsFalse(done); + + e.Dispose(); + Assert.IsTrue(done); + } + + [TestMethod] + public void Finally3() + { + var done = false; + + var ex = new MyException(); + var xs = EnumerableEx.Throw(ex).Finally(() => done = true); + Assert.IsFalse(done); + + var e = xs.GetEnumerator(); + Assert.IsFalse(done); + + try + { + HasNext(e, 0); + Assert.Fail(); + } + catch (MyException ex_) + { + Assert.AreSame(ex, ex_); + } + + Assert.IsTrue(done); + } + + [TestMethod] + public void OnErrorResumeNext_Arguments() + { + AssertThrows(() => EnumerableEx.OnErrorResumeNext(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.OnErrorResumeNext(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.OnErrorResumeNext(default(IEnumerable[]))); + AssertThrows(() => EnumerableEx.OnErrorResumeNext(default(IEnumerable>))); + } + + [TestMethod] + public void OnErrorResumeNext1() + { + var xs = new[] { 1, 2 }; + var ys = new[] { 3, 4 }; + + var res = xs.OnErrorResumeNext(ys); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + } + + [TestMethod] + public void OnErrorResumeNext2() + { + var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw(new MyException())); + var ys = new[] { 3, 4 }; + + var res = xs.OnErrorResumeNext(ys); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + } + + [TestMethod] + public void OnErrorResumeNext3() + { + var xs = new[] { 1, 2 }; + var ys = new[] { 3, 4 }; + var zs = new[] { 5, 6 }; + + var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 })); + } + + [TestMethod] + public void OnErrorResumeNext4() + { + var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw(new MyException())); + var ys = new[] { 3, 4 }; + var zs = new[] { 5, 6 }; + + var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 })); + } + + [TestMethod] + public void OnErrorResumeNext5() + { + var xs = new[] { 1, 2 }; + var ys = new[] { 3, 4 }; + + var res = new[] { xs, ys }.OnErrorResumeNext(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + } + + [TestMethod] + public void OnErrorResumeNext6() + { + var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw(new MyException())); + var ys = new[] { 3, 4 }; + + var res = new[] { xs, ys }.OnErrorResumeNext(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + } + + [TestMethod] + public void Retry_Arguments() + { + AssertThrows(() => EnumerableEx.Retry(null)); + AssertThrows(() => EnumerableEx.Retry(null, 5)); + AssertThrows(() => EnumerableEx.Retry(new[] { 1 }, -1)); + } + + [TestMethod] + public void Retry1() + { + var xs = Enumerable.Range(0, 10); + + var res = xs.Retry(); + Assert.IsTrue(Enumerable.SequenceEqual(res, xs)); + } + + [TestMethod] + public void Retry2() + { + var xs = Enumerable.Range(0, 10); + + var res = xs.Retry(2); + Assert.IsTrue(Enumerable.SequenceEqual(res, xs)); + } + + [TestMethod] + public void Retry3() + { + var ex = new MyException(); + var xs = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw(ex)); + + var res = xs.Retry(2); + var e = res.GetEnumerator(); + HasNext(e, 0); + HasNext(e, 1); + HasNext(e, 0); + HasNext(e, 1); + AssertThrows(() => e.MoveNext(), ex_ => ex == ex_); + } + } +} diff --git a/Ix/Tests/Tests.Imperative.cs b/Ix/Tests/Tests.Imperative.cs new file mode 100644 index 0000000..3b038c6 --- /dev/null +++ b/Ix/Tests/Tests.Imperative.cs @@ -0,0 +1,180 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void While_Arguments() + { + AssertThrows(() => EnumerableEx.While(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.While(() => true, null)); + } + + [TestMethod] + public void While1() + { + var x = 5; + var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 })); + } + + [TestMethod] + public void While2() + { + var x = 0; + var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new int[0])); + } + + [TestMethod] + public void DoWhile_Arguments() + { + AssertThrows(() => EnumerableEx.DoWhile(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.DoWhile(null, () => true)); + } + + [TestMethod] + public void DoWhile1() + { + var x = 5; + var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 })); + } + + [TestMethod] + public void DoWhile2() + { + var x = 0; + var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0 })); + } + + [TestMethod] + public void If_Arguments() + { + AssertThrows(() => EnumerableEx.If(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.If(() => true, null)); + AssertThrows(() => EnumerableEx.If(null, new[] { 1 }, new[] { 1 })); + AssertThrows(() => EnumerableEx.If(() => true, null, new[] { 1 })); + AssertThrows(() => EnumerableEx.If(() => true, new[] { 1 }, null)); + } + + [TestMethod] + public void If1() + { + var x = 5; + var res = EnumerableEx.If(() => x > 0, new[] { +1 }, new[] { -1 }); + + Assert.AreEqual(+1, res.Single()); + + x = -x; + Assert.AreEqual(-1, res.Single()); + } + + [TestMethod] + public void If2() + { + var x = 5; + var res = EnumerableEx.If(() => x > 0, new[] { +1 }); + + Assert.AreEqual(+1, res.Single()); + + x = -x; + Assert.IsTrue(res.IsEmpty()); + } + + [TestMethod] + public void Case_Arguments() + { + AssertThrows(() => EnumerableEx.Case(null, new Dictionary>())); + AssertThrows(() => EnumerableEx.Case(() => 1, null)); + AssertThrows(() => EnumerableEx.Case(null, new Dictionary>(), new[] { 1 })); + AssertThrows(() => EnumerableEx.Case(() => 1, null, new[] { 1 })); + AssertThrows(() => EnumerableEx.Case(() => 1, new Dictionary>(), null)); + } + + [TestMethod] + public void Case1() + { + var x = 1; + var d = 'd'; + var res = EnumerableEx.Case(() => x, new Dictionary> + { + { 0, new[] { 'a' } }, + { 1, new[] { 'b' } }, + { 2, new[] { 'c' } }, + { 3, EnumerableEx.Defer(() => new[] { d }) }, + }); + + Assert.AreEqual('b', res.Single()); + Assert.AreEqual('b', res.Single()); + + x = 0; + Assert.AreEqual('a', res.Single()); + + x = 2; + Assert.AreEqual('c', res.Single()); + + x = 3; + Assert.AreEqual('d', res.Single()); + + d = 'e'; + Assert.AreEqual('e', res.Single()); + + x = 4; + Assert.IsTrue(res.IsEmpty()); + } + + [TestMethod] + public void Case2() + { + var x = 1; + var d = 'd'; + var res = EnumerableEx.Case(() => x, new Dictionary> + { + { 0, new[] { 'a' } }, + { 1, new[] { 'b' } }, + { 2, new[] { 'c' } }, + { 3, EnumerableEx.Defer(() => new[] { d }) }, + }, new[] { 'z' }); + + Assert.AreEqual('b', res.Single()); + Assert.AreEqual('b', res.Single()); + + x = 0; + Assert.AreEqual('a', res.Single()); + + x = 2; + Assert.AreEqual('c', res.Single()); + + x = 3; + Assert.AreEqual('d', res.Single()); + + d = 'e'; + Assert.AreEqual('e', res.Single()); + + x = 4; + Assert.AreEqual('z', res.Single()); + } + + [TestMethod] + public void For_Arguments() + { + AssertThrows(() => EnumerableEx.For(null, x => new[] { 1 })); + AssertThrows(() => EnumerableEx.For(new[] { 1 }, null)); + } + + [TestMethod] + public void For() + { + var res = EnumerableEx.For(new[] { 1, 2, 3 }, x => Enumerable.Range(0, x)).ToList(); + Assert.IsTrue(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2 })); + } + } +} diff --git a/Ix/Tests/Tests.Multiple.cs b/Ix/Tests/Tests.Multiple.cs new file mode 100644 index 0000000..3df8927 --- /dev/null +++ b/Ix/Tests/Tests.Multiple.cs @@ -0,0 +1,74 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void Concat_Arguments() + { + AssertThrows(() => EnumerableEx.Concat(default(IEnumerable[]))); + AssertThrows(() => EnumerableEx.Concat(default(IEnumerable>))); + } + + [TestMethod] + public void Concat1() + { + var res = new[] + { + new[] { 1, 2, 3 }, + new[] { 4, 5 } + }.Concat(); + + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 })); + } + + [TestMethod] + public void Concat2() + { + var i = 0; + var xss = Enumerable.Range(0, 3).Select(x => Enumerable.Range(0, x + 1)).Do(_ => ++i); + + var res = xss.Concat().Select(x => i + " - " + x).ToList(); + + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { + "1 - 0", + "2 - 0", + "2 - 1", + "3 - 0", + "3 - 1", + "3 - 2", + })); + } + + [TestMethod] + public void Concat3() + { + var res = EnumerableEx.Concat( + new[] { 1, 2, 3 }, + new[] { 4, 5 } + ); + + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 })); + } + + [TestMethod] + public void SelectMany_Arguments() + { + AssertThrows(() => EnumerableEx.SelectMany(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.SelectMany(new[] { 1 }, null)); + } + + [TestMethod] + public void SelectMany() + { + var res = new[] { 1, 2 }.SelectMany(new[] { 'a', 'b', 'c' }).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 'a', 'b', 'c', 'a', 'b', 'c' })); + } + } +} diff --git a/Ix/Tests/Tests.Qbservable.cs b/Ix/Tests/Tests.Qbservable.cs new file mode 100644 index 0000000..d174eee --- /dev/null +++ b/Ix/Tests/Tests.Qbservable.cs @@ -0,0 +1,139 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if !SILVERLIGHTM7 + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Reflection; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Runtime.CompilerServices; +using System.Linq.Expressions; +using System.ComponentModel; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void Queryable_Enumerable_Parity() + { + var enu = typeof(EnumerableEx).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList(); + var qry = typeof(QueryableEx).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList(); + + var onlyInObs = enu.Select(m => m.Name).Except(qry.Select(m => m.Name)).Except(new[] { "ForEach", "ToEnumerable", "Multicast", "GetAwaiter", "ToEvent", "ToEventPattern", "ForEachAsync" }).ToList(); + var onlyInQbs = qry.Select(m => m.Name).Except(enu.Select(m => m.Name)).Except(new[] { "ToQueryable", "get_Provider", "Empty", "Range" }).ToList(); + + Assert.IsTrue(onlyInObs.Count == 0, "Missing Queryable operator: " + string.Join(", ", onlyInObs.ToArray())); + Assert.IsTrue(onlyInQbs.Count == 0, "Missing Enumerable operator: " + string.Join(", ", onlyInQbs.ToArray())); + + var enus = enu.GroupBy(m => m.Name); + var qrys = qry.GroupBy(m => m.Name); + var mtch = (from o in enus + join q in qrys on o.Key equals q.Key + select new { Name = o.Key, Enumerable = o.ToList(), Queryable = q.ToList() }) + .ToList(); + + Func filterReturn = t => + { + if (t.IsGenericType) + { + var gd = t.GetGenericTypeDefinition(); + if (gd == typeof(IBuffer<>)) + return false; + } + return true; + }; + + Func filterHelper = m => + { + return !m.IsDefined(typeof(EditorBrowsableAttribute), false); + }; + + foreach (var group in mtch) + { + var oss = group.Enumerable.Where(m => filterReturn(m.ReturnType)).Select(m => GetSignature(m, false)).OrderBy(x => x).ToList(); + var qss = group.Queryable.Where(m => filterHelper(m)).Select(m => GetSignature(m, true)).OrderBy(x => x).ToList(); + + Assert.IsTrue(oss.SequenceEqual(qss), "Mismatch between QueryableEx and EnumerableEx for " + group.Name); + } + } + + public static string GetSignature(MethodInfo m, bool correct) + { + var ps = m.GetParameters(); + var pss = ps.AsEnumerable(); + if (correct && ps.Length > 0 && ps[0].ParameterType == typeof(IQueryProvider)) + pss = pss.Skip(1); + + var gens = m.IsGenericMethod ? string.Format("<{0}>", string.Join(", ", m.GetGenericArguments().Select(a => GetTypeName(a, correct)).ToArray())) : ""; + + var pars = string.Join(", ", pss.Select(p => (Attribute.IsDefined(p, typeof(ParamArrayAttribute)) ? "params " : "") + GetTypeName(p.ParameterType, correct) + " " + p.Name).ToArray()); + if (Attribute.IsDefined(m, typeof(ExtensionAttribute))) + { + if (pars.StartsWith("IQbservable") || pars.StartsWith("IQueryable")) + pars = "this " + pars; + } + + return string.Format("{0} {1}{2}({3})", GetTypeName(m.ReturnType, correct), m.Name, gens, pars); + } + + public static string GetTypeName(Type t, bool correct) + { + if (t.IsGenericType) + { + var gtd = t.GetGenericTypeDefinition(); + if (gtd == typeof(Expression<>)) + return GetTypeName(t.GetGenericArguments()[0], false); + + var args = string.Join(", ", t.GetGenericArguments().Select(a => GetTypeName(a, false)).ToArray()); + + var len = t.Name.IndexOf('`'); + var name = len >= 0 ? t.Name.Substring(0, len) : t.Name; + if (correct && name == "IQbservable") + name = "IObservable"; + if (correct && name == "IQueryable") + name = "IEnumerable"; + + return string.Format("{0}<{1}>", name, args); + } + + if (t.IsArray) + { + return GetTypeName(t.GetElementType(), correct) + "[]"; + } + + return t.Name; + } + + [TestMethod] + public void QueryableRetarget1() + { + var res = QueryableEx.Provider.Empty().AsEnumerable().ToList(); + Assert.IsTrue(res.SequenceEqual(new int[0])); + } + + [TestMethod] + public void QueryableRetarget2() + { + var res = QueryableEx.Provider.Return(42).AsEnumerable().ToList(); + Assert.IsTrue(res.SequenceEqual(new[] { 42 })); + } + + [TestMethod] + public void QueryableRetarget3() + { + var res = Enumerable.Range(0, 10).AsQueryable().TakeLast(2).AsEnumerable().ToList(); + Assert.IsTrue(res.SequenceEqual(new[] { 8, 9 })); + } + + [TestMethod] + public void QueryableRetarget4() + { + var res = QueryableEx.Provider.Range(0, 10).AsEnumerable().ToList(); + Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); + } + } +} + +#endif \ No newline at end of file diff --git a/Ix/Tests/Tests.Single.cs b/Ix/Tests/Tests.Single.cs new file mode 100644 index 0000000..6054f54 --- /dev/null +++ b/Ix/Tests/Tests.Single.cs @@ -0,0 +1,431 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + public partial class Tests + { + [TestMethod] + public void Hide_Arguments() + { + AssertThrows(() => EnumerableEx.Hide(null)); + } + + [TestMethod] + public void Hide() + { + var xs = new List { 1, 2, 3 }; + var ys = xs.Hide(); + Assert.IsFalse(ys is List); + Assert.IsTrue(xs.SequenceEqual(ys)); + } + + [TestMethod] + public void ForEach_Arguments() + { + AssertThrows(() => EnumerableEx.ForEach(null, x => { })); + AssertThrows(() => EnumerableEx.ForEach(new[] { 1 }, default(Action))); + AssertThrows(() => EnumerableEx.ForEach(null, (x, i) => { })); + AssertThrows(() => EnumerableEx.ForEach(new[] { 1 }, default(Action))); + } + + [TestMethod] + public void ForEach1() + { + var n = 0; + Enumerable.Range(5, 3).ForEach(x => n += x); + Assert.AreEqual(5 + 6 + 7, n); + } + + [TestMethod] + public void ForEach2() + { + var n = 0; + Enumerable.Range(5, 3).ForEach((x, i) => n += x * i); + Assert.AreEqual(5 * 0 + 6 * 1 + 7 * 2, n); + } + + [TestMethod] + public void Buffer_Arguments() + { + AssertThrows(() => EnumerableEx.Buffer(null, 5)); + AssertThrows(() => EnumerableEx.Buffer(null, 5, 3)); + AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 0)); + AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 5, 0)); + AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 0, 3)); + } + + [TestMethod] + public void Buffer1() + { + var rng = Enumerable.Range(0, 10); + + var res = rng.Buffer(3).ToList(); + Assert.AreEqual(4, res.Count); + + Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 })); + Assert.IsTrue(res[1].SequenceEqual(new[] { 3, 4, 5 })); + Assert.IsTrue(res[2].SequenceEqual(new[] { 6, 7, 8 })); + Assert.IsTrue(res[3].SequenceEqual(new[] { 9 })); + } + + [TestMethod] + public void Buffer2() + { + var rng = Enumerable.Range(0, 10); + + var res = rng.Buffer(5).ToList(); + Assert.AreEqual(2, res.Count); + + Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2, 3, 4 })); + Assert.IsTrue(res[1].SequenceEqual(new[] { 5, 6, 7, 8, 9 })); + } + + [TestMethod] + public void Buffer3() + { + var rng = Enumerable.Empty(); + + var res = rng.Buffer(5).ToList(); + Assert.AreEqual(0, res.Count); + } + + [TestMethod] + public void Buffer4() + { + var rng = Enumerable.Range(0, 10); + + var res = rng.Buffer(3, 2).ToList(); + Assert.AreEqual(5, res.Count); + + Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 })); + Assert.IsTrue(res[1].SequenceEqual(new[] { 2, 3, 4 })); + Assert.IsTrue(res[2].SequenceEqual(new[] { 4, 5, 6 })); + Assert.IsTrue(res[3].SequenceEqual(new[] { 6, 7, 8 })); + Assert.IsTrue(res[4].SequenceEqual(new[] { 8, 9 })); + } + + [TestMethod] + public void Buffer5() + { + var rng = Enumerable.Range(0, 10); + + var res = rng.Buffer(3, 4).ToList(); + Assert.AreEqual(3, res.Count); + + Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 })); + Assert.IsTrue(res[1].SequenceEqual(new[] { 4, 5, 6 })); + Assert.IsTrue(res[2].SequenceEqual(new[] { 8, 9 })); + } + + [TestMethod] + public void Do_Arguments() + { + AssertThrows(() => EnumerableEx.Do(null, _ => { })); + AssertThrows(() => EnumerableEx.Do(null, _ => { }, () => { })); + AssertThrows(() => EnumerableEx.Do(null, _ => { }, _ => { })); + AssertThrows(() => EnumerableEx.Do(null, _ => { }, _ => { }, () => { })); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action))); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), () => { })); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action))); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), _ => { }, () => { })); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action), () => { })); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, _ => { }, default(Action))); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), _ => { })); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action))); +#if !NO_RXINTERFACES + AssertThrows(() => EnumerableEx.Do(null, new MyObserver())); + AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(IObserver))); +#endif + } + + [TestMethod] + public void Do1() + { + var n = 0; + Enumerable.Range(0, 10).Do(x => n += x).ForEach(_ => { }); + Assert.AreEqual(45, n); + } + + [TestMethod] + public void Do2() + { + var n = 0; + Enumerable.Range(0, 10).Do(x => n += x, () => n *= 2).ForEach(_ => { }); + Assert.AreEqual(90, n); + } + + [TestMethod] + public void Do3() + { + var ex = new MyException(); + var ok = false; + AssertThrows(() => + EnumerableEx.Throw(ex).Do(x => { Assert.Fail(); }, e => { Assert.AreEqual(ex, e); ok = true; }).ForEach(_ => { }) + ); + Assert.IsTrue(ok); + } + +#if !NO_RXINTERFACES + [TestMethod] + public void Do4() + { + var obs = new MyObserver(); + Enumerable.Range(0, 10).Do(obs).ForEach(_ => { }); + + Assert.IsTrue(obs.Done); + Assert.AreEqual(45, obs.Sum); + } + + class MyObserver : IObserver + { + public int Sum; + public bool Done; + + public void OnCompleted() + { + Done = true; + } + + public void OnError(Exception error) + { + throw new NotImplementedException(); + } + + public void OnNext(int value) + { + Sum += value; + } + } +#endif + + [TestMethod] + public void Do5() + { + var sum = 0; + var done = false; + Enumerable.Range(0, 10).Do(x => sum += x, ex => { throw ex; }, () => done = true).ForEach(_ => { }); + + Assert.IsTrue(done); + Assert.AreEqual(45, sum); + } + + [TestMethod] + public void StartWith_Arguments() + { + AssertThrows(() => EnumerableEx.StartWith(null, 5)); + } + + [TestMethod] + public void StartWith1() + { + var e = Enumerable.Range(1, 5); + var r = e.StartWith(0).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, Enumerable.Range(0, 6))); + } + + [TestMethod] + public void StartWith2() + { + var oops = false; + var e = Enumerable.Range(1, 5).Do(_ => oops = true); + var r = e.StartWith(0).Take(1).ToList(); + Assert.IsFalse(oops); + } + + [TestMethod] + public void Expand_Arguments() + { + AssertThrows(() => EnumerableEx.Expand(null, _ => new[] { _ })); + AssertThrows(() => EnumerableEx.Expand(new[] { 1 }, null)); + } + + [TestMethod] + public void Expand1() + { + var res = new[] { 0 }.Expand(x => new[] { x + 1 }).Take(10).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, Enumerable.Range(0, 10))); + } + + [TestMethod] + public void Expand2() + { + var res = new[] { 3 }.Expand(x => Enumerable.Range(0, x)).ToList(); + var exp = new[] { + 3, + 0, 1, 2, + 0, + 0, 1, + 0 + }; + Assert.IsTrue(Enumerable.SequenceEqual(res, exp)); + } + + [TestMethod] + public void Distinct_Arguments() + { + AssertThrows(() => EnumerableEx.Distinct(null, _ => _)); + AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Distinct(null, _ => _, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, null, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, _ => _, null)); + } + + [TestMethod] + public void Distinct1() + { + var res = Enumerable.Range(0, 10).Distinct(x => x % 5).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, Enumerable.Range(0, 5))); + } + + [TestMethod] + public void Distinct2() + { + var res = Enumerable.Range(0, 10).Distinct(x => x % 5, new MyEqualityComparer()).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0, 1 })); + } + + class MyEqualityComparer : IEqualityComparer + { + public bool Equals(int x, int y) + { + return x % 2 == y % 2; + } + + public int GetHashCode(int obj) + { + return EqualityComparer.Default.GetHashCode(obj % 2); + } + } + + [TestMethod] + public void DistinctUntilChanged_Arguments() + { + AssertThrows(() => EnumerableEx.DistinctUntilChanged(null)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, _ => _)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, _ => _, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, _ => _, null)); + } + + [TestMethod] + public void DistinctUntilChanged1() + { + var res = new[] { 1, 2, 2, 3, 3, 3, 2, 2, 1 }.DistinctUntilChanged().ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 2, 1 })); + } + + [TestMethod] + public void DistinctUntilChanged2() + { + var res = new[] { 1, 1, 2, 3, 4, 5, 5, 6, 7 }.DistinctUntilChanged(x => x / 2).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 4, 6 })); + } + + [TestMethod] + public void IgnoreElements_Arguments() + { + AssertThrows(() => EnumerableEx.IgnoreElements(null)); + } + + [TestMethod] + public void IgnoreElements() + { + var n = 0; + Enumerable.Range(0, 10).Do(_ => n++).IgnoreElements().Take(5).ForEach(_ => { }); + Assert.AreEqual(10, n); + } + + [TestMethod] + public void TakeLast_Arguments() + { + AssertThrows(() => EnumerableEx.TakeLast(null, 5)); + AssertThrows(() => EnumerableEx.TakeLast(new[] { 1 }, -1)); + } + + [TestMethod] + public void TakeLast_Empty() + { + var e = Enumerable.Empty(); + var r = e.TakeLast(1).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, e)); + } + + [TestMethod] + public void TakeLast_All() + { + var e = Enumerable.Range(0, 5); + var r = e.TakeLast(5).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, e)); + } + + [TestMethod] + public void TakeLast_Part() + { + var e = Enumerable.Range(0, 5); + var r = e.TakeLast(3).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, e.Skip(2))); + } + + [TestMethod] + public void SkipLast_Arguments() + { + AssertThrows(() => EnumerableEx.SkipLast(null, 5)); + AssertThrows(() => EnumerableEx.SkipLast(new[] { 1 }, -1)); + } + + [TestMethod] + public void SkipLast_Empty() + { + var e = Enumerable.Empty(); + var r = e.SkipLast(1).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, e)); + } + + [TestMethod] + public void SkipLast_All() + { + var e = Enumerable.Range(0, 5); + var r = e.SkipLast(0).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, e)); + } + + [TestMethod] + public void SkipLast_Part() + { + var e = Enumerable.Range(0, 5); + var r = e.SkipLast(3).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(r, e.Take(2))); + } + + [TestMethod] + public void Scan_Arguments() + { + AssertThrows(() => EnumerableEx.Scan(null, (x, y) => x + y)); + AssertThrows(() => EnumerableEx.Scan(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Scan(null, 0, (x, y) => x + y)); + AssertThrows(() => EnumerableEx.Scan(new[] { 1 }, 0, null)); + } + + [TestMethod] + public void Scan1() + { + var res = Enumerable.Range(0, 5).Scan((n, x) => n + x).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 3, 6, 10 })); + } + + [TestMethod] + public void Scan2() + { + var res = Enumerable.Range(0, 5).Scan(10, (n, x) => n - x).ToList(); + Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 10, 9, 7, 4, 0 })); + } + } +} diff --git a/Ix/Tests/Tests.cs b/Ix/Tests/Tests.cs new file mode 100644 index 0000000..27dca14 --- /dev/null +++ b/Ix/Tests/Tests.cs @@ -0,0 +1,51 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Tests +{ + [TestClass] + public partial class Tests + { + public void AssertThrows(Action a) + where E : Exception + { + try + { + a(); + Assert.Fail(); + } + catch (E) + { + } + } + + public void AssertThrows(Action a, Func assert) + where E : Exception + { + try + { + a(); + Assert.Fail(); + } + catch (E e) + { + Assert.IsTrue(assert(e)); + } + } + + public void NoNext(IEnumerator e) + { + Assert.IsFalse(e.MoveNext()); + } + + public void HasNext(IEnumerator e, T value) + { + Assert.IsTrue(e.MoveNext()); + Assert.AreEqual(value, e.Current); + } + } +} diff --git a/Ix/Tests/Tests.csproj b/Ix/Tests/Tests.csproj new file mode 100644 index 0000000..f3f57ff --- /dev/null +++ b/Ix/Tests/Tests.csproj @@ -0,0 +1,91 @@ + + + + Debug + AnyCPU + + + 2.0 + {C4C8532A-F8D2-428B-962E-FD578A1E647C} + Library + Properties + Tests + Tests + v4.0 + 512 + {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + + true + true + $(AssemblyName).xap + true + Properties\AppManifest.xml + InteractiveTests.App + TestPage.html + true + + + + _$(AssemblyName) + + + + + ..\..\..\..\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll + + + + + + + + + true + + + + + + + False + + + + + + + + + + + + + + + + + + + + + + + + + + {7269A578-326A-4C3E-9874-A2D2600095BC} + System.Interactive.Async + + + {6D62E966-469D-4A99-BD43-0A17FA14FB4F} + System.Interactive.Providers + + + {8E4B04F0-915E-48F9-9796-76278C6094BD} + System.Interactive + + + + \ No newline at end of file diff --git a/Ix/TraceAndTestImpact.testsettings b/Ix/TraceAndTestImpact.testsettings new file mode 100644 index 0000000..363295b --- /dev/null +++ b/Ix/TraceAndTestImpact.testsettings @@ -0,0 +1,21 @@ + + + These are test settings for Trace and Test Impact. + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Ix/license.txt b/Ix/license.txt new file mode 100644 index 0000000..d7fd6c0 --- /dev/null +++ b/Ix/license.txt @@ -0,0 +1,15 @@ +Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +Microsoft Open Technologies would like to thank its contributors, a list +of whom are at http://aspnetwebstack.codeplex.com/wikipage?title=Contributors. + +Licensed under the Apache License, Version 2.0 (the "License"); you +may not use this file except in compliance with the License. You may +obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied. See the License for the specific language governing permissions +and limitations under the License. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..7a0a1e2 --- /dev/null +++ b/README.md @@ -0,0 +1,24 @@ +# Reactive Extensions Libraries + + +Tx is set of code samples showing how to use LINQ to events, such as: + +* **Real-Time standing queries:**. E.g. producing a histogram every second how many bytes were send/received over TCP per IP address. +* **Queries on past history from trace/log files:** E.g. from past trace of IIS find the slow requests by correlating "begin" and "end" events. + +The initial set of supported technologies is: + +* Event Tracing for Windows (ETW) +* Windows Event Logs +* SQL Server Extended Events (XEvent) + + + +* Reactive Extensions: ** Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. ** RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. ** Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. * Interactive Extensions ** Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. ** IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. ** Ix++: An implantation of LINQ for Native Developers in C++ * Bindings: ** Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. ** LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. +#Contributing Code Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. + + + + + + diff --git a/Rx++/.gitattributes b/Rx++/.gitattributes new file mode 100644 index 0000000..412eeda --- /dev/null +++ b/Rx++/.gitattributes @@ -0,0 +1,22 @@ +# Auto detect text files and perform LF normalization +* text=auto + +# Custom for Visual Studio +*.cs diff=csharp +*.sln merge=union +*.csproj merge=union +*.vbproj merge=union +*.fsproj merge=union +*.dbproj merge=union + +# Standard to msysgit +*.doc diff=astextplain +*.DOC diff=astextplain +*.docx diff=astextplain +*.DOCX diff=astextplain +*.dot diff=astextplain +*.DOT diff=astextplain +*.pdf diff=astextplain +*.PDF diff=astextplain +*.rtf diff=astextplain +*.RTF diff=astextplain diff --git a/Rx++/.gitignore b/Rx++/.gitignore new file mode 100644 index 0000000..5ebd21a --- /dev/null +++ b/Rx++/.gitignore @@ -0,0 +1,163 @@ +################# +## Eclipse +################# + +*.pydevproject +.project +.metadata +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.classpath +.settings/ +.loadpath + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# CDT-specific +.cproject + +# PDT-specific +.buildpath + + +################# +## Visual Studio +################# + +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.sln.docstates + +# Build results +[Dd]ebug/ +[Rr]elease/ +*_i.c +*_p.c +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.vspscc +.builds +*.dotCover + +## TODO: If you have NuGet Package Restore enabled, uncomment this +#packages/ + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf + +# Visual Studio profiler +*.psess +*.vsp + +# ReSharper is a .NET coding add-in +_ReSharper* + +# Installshield output folder +[Ee]xpress + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish + +# Others +[Bb]in +[Oo]bj +sql +TestResults +*.Cache +ClientBin +stylecop.* +~$* +*.dbmdl +Generated_Code #added for RIA/Silverlight projects + +# Backup & report files from converting an old project file to a newer +# Visual Studio version. Backup files are not needed, because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML + + + +############ +## Windows +############ + +# Windows image file caches +Thumbs.db + +# Folder config file +Desktop.ini + + +############# +## Python +############# + +*.py[co] + +# Packages +*.egg +*.egg-info +dist +build +eggs +parts +bin +var +sdist +develop-eggs +.installed.cfg + +# Installer logs +pip-log.txt + +# Unit test / coverage reports +.coverage +.tox + +#Translations +*.mo + +#Mr Developer +.mr.developer.cfg + +# Mac crap +.DS_Store diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp new file mode 100644 index 0000000..ed928a0 --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -0,0 +1,171 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + + +// MainFrm.cpp : implementation of the CMainFrame class +// + +#include "stdafx.h" +#include "MfcTimeFliesLikeAnArrow.h" + +#include "MainFrm.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CMainFrame + +IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd) + +BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) + ON_WM_CREATE() +// ON_WM_SETFOCUS() + ON_WM_CLOSE() + ON_WM_MOUSEMOVE() + ON_WM_PAINT() +END_MESSAGE_MAP() + +static UINT indicators[] = +{ + ID_SEPARATOR, // status line indicator + ID_INDICATOR_CAPS, + ID_INDICATOR_NUM, + ID_INDICATOR_SCRL, +}; + +// CMainFrame construction/destruction + +CMainFrame::CMainFrame() +{ + // TODO: add member initialization code here +} + +CMainFrame::~CMainFrame() +{ +} + + +// inspired by: http://minirx.codeplex.com/ +void CMainFrame::UserInit() +{ + auto mouseMove = BindEventToObservable(mouseMoveEvent); + + // set up labels and query + auto msg = L"Time flies like an arrow"; + + for (int i = 0; msg[i]; ++i) + { + auto label = CreateLabelFromLetter(msg[i], this); + + // note: distinct_until_changed is necessary; while + // Winforms filters duplicate mouse moves, + // user32 doesn't filter this for you: http://blogs.msdn.com/b/oldnewthing/archive/2003/10/01/55108.aspx + + auto s = rxcpp::from(mouseMove) + .select([](MouseMoveEventValue e) { return e.point; }) + .distinct_until_changed() + .delay(i * 100 + 1) + .on_dispatcher() + .subscribe([=](CPoint point) + { + label->SetWindowPos(nullptr, point.x+20*i, point.y-20, 20, 30, SWP_NOOWNERZORDER); + label->Invalidate(); + + // repaint early, for fluid animation + label->UpdateWindow(); + this->UpdateWindow(); + }); + + composableDisposable.Add(s); + } +} + +void CMainFrame::OnClose() +{ + // TODO: figure out cause of crash -- until then, exit instead + ::ExitProcess(0); + + // shutdown subscription. + composableDisposable.Dispose(); + + CFrameWnd::OnClose(); +} + + +int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) +{ + if (CFrameWnd::OnCreate(lpCreateStruct) == -1) + return -1; + + if (!m_wndStatusBar.Create(this)) + { + TRACE0("Failed to create status bar\n"); + return -1; // fail to create + } + m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT)); + + UserInit(); + + return 0; +} + +BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) +{ + if( !CFrameWnd::PreCreateWindow(cs) ) + return FALSE; + + cs.dwExStyle &= ~WS_EX_CLIENTEDGE; + cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS, ::LoadCursor(NULL, IDC_ARROW)); + return TRUE; +} + +// CMainFrame diagnostics + +#ifdef _DEBUG +void CMainFrame::AssertValid() const +{ + CFrameWnd::AssertValid(); +} + +void CMainFrame::Dump(CDumpContext& dc) const +{ + CFrameWnd::Dump(dc); +} +#endif //_DEBUG + + +// CMainFrame message handlers + +void CMainFrame::OnSetFocus(CWnd* /*pOldWnd*/) +{ + // forward focus to the view window + //m_wndView.SetFocus(); +} + +BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) +{ + // let the view have first crack at the command + //if (m_wndView.OnCmdMsg(nID, nCode, pExtra, pHandlerInfo)) + // return TRUE; + + // otherwise, do default handling + return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo); +} + +void CMainFrame::OnMouseMove(UINT nFlags, CPoint point) +{ + MouseMoveEventValue v = {nFlags, point}; + this->mouseMoveEvent(v); +} + +void CMainFrame::OnPaint( ) +{ + CPaintDC dc(this); // device context for painting + + RECT rc; + this->GetClientRect(&rc); + CBrush brush; + brush.CreateSolidBrush(RGB(240,240,240)); + dc.FillRect(&rc, &brush); +} + diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h b/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h new file mode 100644 index 0000000..040bc7d --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h @@ -0,0 +1,91 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + + +// MainFrm.h : interface of the CMainFrame class +// + +#pragma once + + +template +static std::shared_ptr> + BindEventToObservable(std::function& event) +{ + auto eSubject = rxcpp::CreateSubject(); + event = [=](const T& eventValue) { + eSubject->OnNext(eventValue); + }; + return eSubject; +} + +inline CStatic* CreateLabelFromLetter(wchar_t c, CWnd* parent) +{ + CStatic* label; + label = new CStatic(); + + RECT r = { 0, 0, }; + r.right = r.left+20; + r.bottom = r.top + 30; + + auto message = new std::wstring(&c, &c+1); + label->Create( + message->c_str(), + WS_CHILD | WS_VISIBLE, + r, + parent); + return label; +} + +class CMainFrame : public CFrameWnd +{ + +public: + CMainFrame(); +protected: + DECLARE_DYNAMIC(CMainFrame) + +// Attributes +public: + +// Operations +public: + +// Overrides +public: + virtual BOOL PreCreateWindow(CREATESTRUCT& cs); + virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo); + +// Implementation +public: + virtual ~CMainFrame(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + +protected: // control bar embedded members + CStatusBar m_wndStatusBar; + + struct MouseMoveEventValue + { + UINT nFlags; + CPoint point; + }; + + std::function mouseMoveEvent; + +// Generated message map functions +protected: + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + afx_msg void OnSetFocus(CWnd *pOldWnd); + afx_msg void OnClose(); + afx_msg void OnMouseMove(UINT nFlags, CPoint point); + afx_msg void OnPaint( ); + + DECLARE_MESSAGE_MAP() + + void UserInit(); + rxcpp::ComposableDisposable composableDisposable; +}; + + diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp new file mode 100644 index 0000000..59c726a --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp @@ -0,0 +1,153 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +// MfcTimeFliesLikeAnArrow.cpp : Defines the class behaviors for the application. +// + +#include "stdafx.h" +#include "afxwinappex.h" +#include "afxdialogex.h" +#include "MfcTimeFliesLikeAnArrow.h" +#include "MainFrm.h" + + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + + +// CMfcTimeFliesLikeAnArrowApp + +BEGIN_MESSAGE_MAP(CMfcTimeFliesLikeAnArrowApp, CWinApp) + ON_COMMAND(ID_APP_ABOUT, &CMfcTimeFliesLikeAnArrowApp::OnAppAbout) +END_MESSAGE_MAP() + + +// CMfcTimeFliesLikeAnArrowApp construction + +CMfcTimeFliesLikeAnArrowApp::CMfcTimeFliesLikeAnArrowApp() +{ + // support Restart Manager + m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART; +#ifdef _MANAGED + // If the application is built using Common Language Runtime support (/clr): + // 1) This additional setting is needed for Restart Manager support to work properly. + // 2) In your project, you must add a reference to System.Windows.Forms in order to build. + System::Windows::Forms::Application::SetUnhandledExceptionMode(System::Windows::Forms::UnhandledExceptionMode::ThrowException); +#endif + + // TODO: replace application ID string below with unique ID string; recommended + // format for string is CompanyName.ProductName.SubProduct.VersionInformation + SetAppID(_T("MfcTimeFliesLikeAnArrow.AppID.NoVersion")); + + // TODO: add construction code here, + // Place all significant initialization in InitInstance +} + +// The one and only CMfcTimeFliesLikeAnArrowApp object + +CMfcTimeFliesLikeAnArrowApp theApp; + + +// CMfcTimeFliesLikeAnArrowApp initialization + +BOOL CMfcTimeFliesLikeAnArrowApp::InitInstance() +{ + // InitCommonControlsEx() is required on Windows XP if an application + // manifest specifies use of ComCtl32.dll version 6 or later to enable + // visual styles. Otherwise, any window creation will fail. + INITCOMMONCONTROLSEX InitCtrls; + InitCtrls.dwSize = sizeof(InitCtrls); + // Set this to include all the common control classes you want to use + // in your application. + InitCtrls.dwICC = ICC_WIN95_CLASSES; + InitCommonControlsEx(&InitCtrls); + + CWinApp::InitInstance(); + + + EnableTaskbarInteraction(FALSE); + + // AfxInitRichEdit2() is required to use RichEdit control + // AfxInitRichEdit2(); + + // Standard initialization + // If you are not using these features and wish to reduce the size + // of your final executable, you should remove from the following + // the specific initialization routines you do not need + // Change the registry key under which our settings are stored + // TODO: You should modify this string to be something appropriate + // such as the name of your company or organization + SetRegistryKey(_T("Local AppWizard-Generated Applications")); + + + // To create the main window, this code creates a new frame window + // object and then sets it as the application's main window object + CMainFrame* pFrame = new CMainFrame; + if (!pFrame) + return FALSE; + m_pMainWnd = pFrame; + // create and load the frame with its resources + pFrame->LoadFrame(IDR_MAINFRAME, + WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL, + NULL); + + + + + + // The one and only window has been initialized, so show and update it + pFrame->ShowWindow(SW_SHOW); + pFrame->UpdateWindow(); + return TRUE; +} + +int CMfcTimeFliesLikeAnArrowApp::ExitInstance() +{ + //TODO: handle additional resources you may have added + return CWinApp::ExitInstance(); +} + +// CMfcTimeFliesLikeAnArrowApp message handlers + + +// CAboutDlg dialog used for App About + +class CAboutDlg : public CDialogEx +{ +public: + CAboutDlg(); + +// Dialog Data + enum { IDD = IDD_ABOUTBOX }; + +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + +// Implementation +protected: + DECLARE_MESSAGE_MAP() +}; + +CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD) +{ +} + +void CAboutDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); +} + +BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx) +END_MESSAGE_MAP() + +// App command to run the dialog +void CMfcTimeFliesLikeAnArrowApp::OnAppAbout() +{ + CAboutDlg aboutDlg; + aboutDlg.DoModal(); +} + +// CMfcTimeFliesLikeAnArrowApp message handlers + + + diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h new file mode 100644 index 0000000..b13b068 --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h @@ -0,0 +1,37 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + + +// MfcTimeFliesLikeAnArrow.h : main header file for the MfcTimeFliesLikeAnArrow application +// +#pragma once + +#ifndef __AFXWIN_H__ + #error "include 'stdafx.h' before including this file for PCH" +#endif + +#include "resource.h" // main symbols + + +// CMfcTimeFliesLikeAnArrowApp: +// See MfcTimeFliesLikeAnArrow.cpp for the implementation of this class +// + +class CMfcTimeFliesLikeAnArrowApp : public CWinApp +{ +public: + CMfcTimeFliesLikeAnArrowApp(); + + +// Overrides +public: + virtual BOOL InitInstance(); + virtual int ExitInstance(); + +// Implementation + +public: + afx_msg void OnAppAbout(); + DECLARE_MESSAGE_MAP() +}; + +extern CMfcTimeFliesLikeAnArrowApp theApp; diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc new file mode 100644 index 0000000..928bb2f --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc @@ -0,0 +1,276 @@ +//Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#ifndef APSTUDIO_INVOKED +#include "targetver.h" +#endif +#include "afxres.h" +#include "verrsrc.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +#ifdef APSTUDIO_INVOKED + +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#ifndef APSTUDIO_INVOKED\r\n" + "#include ""targetver.h""\r\n" + "#endif\r\n" + "#include ""afxres.h""\r\n" + "#include ""verrsrc.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "LANGUAGE 9, 1\r\n" + "#include ""res\\MfcTimeFliesLikeAnArrow.rc2"" // non-Microsoft Visual C++ edited resources\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE 9, 1 +IDR_MAINFRAME ICON "res\\MfcTimeFliesLikeAnArrow.ico" +#endif +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE 9, 1 + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_MAINFRAME MENU +BEGIN + POPUP "&File" + BEGIN + MENUITEM "E&xit", ID_APP_EXIT + END + POPUP "&Edit" + BEGIN + MENUITEM "&Undo\tCtrl+Z", ID_EDIT_UNDO + MENUITEM SEPARATOR + MENUITEM "Cu&t\tCtrl+X", ID_EDIT_CUT + MENUITEM "&Copy\tCtrl+C", ID_EDIT_COPY + MENUITEM "&Paste\tCtrl+V", ID_EDIT_PASTE + END + POPUP "&View" + BEGIN + MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR + END + POPUP "&Help" + BEGIN + MENUITEM "&About MfcTimeFliesLikeAnArrow...", ID_APP_ABOUT + END +END + + + +///////////////////////////////////////////////////////////////////////////// +// +// Accelerator +// + +IDR_MAINFRAME ACCELERATORS +BEGIN + "C", ID_EDIT_COPY, VIRTKEY,CONTROL,NOINVERT + "V", ID_EDIT_PASTE, VIRTKEY,CONTROL,NOINVERT + VK_BACK, ID_EDIT_UNDO, VIRTKEY,ALT,NOINVERT + VK_DELETE, ID_EDIT_CUT, VIRTKEY,SHIFT,NOINVERT + VK_F6, ID_NEXT_PANE, VIRTKEY ,NOINVERT + VK_F6, ID_PREV_PANE, VIRTKEY,SHIFT,NOINVERT + VK_INSERT, ID_EDIT_COPY, VIRTKEY,CONTROL,NOINVERT + VK_INSERT, ID_EDIT_PASTE, VIRTKEY,SHIFT,NOINVERT + "X", ID_EDIT_CUT, VIRTKEY,CONTROL,NOINVERT + "Z", ID_EDIT_UNDO, VIRTKEY,CONTROL,NOINVERT +END + + + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_ABOUTBOX DIALOGEX 0, 0, 170, 62 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "About MfcTimeFliesLikeAnArrow" +FONT 8, "MS Shell Dlg" +BEGIN + ICON IDR_MAINFRAME,IDC_STATIC,14,14,21,20 + LTEXT "MfcTimeFliesLikeAnArrow, Version 1.0",IDC_STATIC,42,14,114,8,SS_NOPREFIX + LTEXT "Copyright (C) 2012",IDC_STATIC,42,26,114,8 + DEFPUSHBUTTON "OK",IDOK,113,41,50,14,WS_GROUP +END + + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif + FILEOS VOS_NT_WINDOWS32 + FILETYPE VFT_APP + FILESUBTYPE VFT2_UNKNOWN +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "CompanyName", "TODO: " + VALUE "FileDescription", "MfcTimeFliesLikeAnArrow" + VALUE "FileVersion", "1.0.0.1" + VALUE "InternalName", "MfcTimeFliesLikeAnArrow.exe" + VALUE "LegalCopyright", "TODO: (c) . All rights reserved." + VALUE "OriginalFilename","MfcTimeFliesLikeAnArrow.exe" + VALUE "ProductName", "TODO: " + VALUE "ProductVersion", "1.0.0.1" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x0409, 1200 + END +END + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_ABOUTBOX, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 163 + TOPMARGIN, 7 + BOTTOMMARGIN, 55 + END +END +#endif // APSTUDIO_INVOKED + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN +// Non-mac-targeting apps remove the two extra substrings + IDR_MAINFRAME "MfcTimeFliesLikeAnArrow" +END +STRINGTABLE +BEGIN + AFX_IDS_APP_TITLE "MfcTimeFliesLikeAnArrow" + AFX_IDS_IDLEMESSAGE "Ready" +END +STRINGTABLE +BEGIN + ID_INDICATOR_EXT "EXT" + ID_INDICATOR_CAPS "CAP" + ID_INDICATOR_NUM "NUM" + ID_INDICATOR_SCRL "SCRL" + ID_INDICATOR_OVR "OVR" + ID_INDICATOR_REC "REC" +END +STRINGTABLE +BEGIN + ID_APP_ABOUT "Display program information, version number and copyright\nAbout" + ID_APP_EXIT "Quit the application; prompts to save documents\nExit" + ID_NEXT_PANE "Switch to the next window pane\nNext Pane" + ID_PREV_PANE "Switch back to the previous window pane\nPrevious Pane" + ID_WINDOW_SPLIT "Split the active window into panes\nSplit" + ID_EDIT_CLEAR "Erase the selection\nErase" + ID_EDIT_CLEAR_ALL "Erase everything\nErase All" + ID_EDIT_COPY "Copy the selection and put it on the Clipboard\nCopy" + ID_EDIT_CUT "Cut the selection and put it on the Clipboard\nCut" + ID_EDIT_FIND "Find the specified text\nFind" + ID_EDIT_PASTE "Insert Clipboard contents\nPaste" + ID_EDIT_REPEAT "Repeat the last action\nRepeat" + ID_EDIT_REPLACE "Replace specific text with different text\nReplace" + ID_EDIT_SELECT_ALL "Select the entire document\nSelect All" + ID_EDIT_UNDO "Undo the last action\nUndo" + ID_EDIT_REDO "Redo the previously undone action\nRedo" + ID_VIEW_STATUS_BAR "Show or hide the status bar\nToggle Status Bar" +END + +STRINGTABLE +BEGIN + AFX_IDS_SCSIZE "Change the window size" + AFX_IDS_SCMOVE "Change the window position" + AFX_IDS_SCMINIMIZE "Reduce the window to an icon" + AFX_IDS_SCMAXIMIZE "Enlarge the window to full size" + AFX_IDS_SCNEXTWINDOW "Switch to the next document window" + AFX_IDS_SCPREVWINDOW "Switch to the previous document window" + AFX_IDS_SCCLOSE "Close the active window and prompts to save the documents" + AFX_IDS_SCRESTORE "Restore the window to normal size" + AFX_IDS_SCTASKLIST "Activate Task List" +END + + +#endif + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE 9, 1 +#include "res\\MfcTimeFliesLikeAnArrow.rc2" // non-Microsoft Visual C++ edited resources +#include "afxres.rc" // Standard components +#endif +#endif // not APSTUDIO_INVOKED diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj new file mode 100644 index 0000000..ecef98f --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj @@ -0,0 +1,137 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + $(VCTargetsPath11) + + + {E773817F-F3E5-4E78-ADD3-B70E11F611B6} + MfcTimeFliesLikeAnArrow + MFCProj + + + + Application + true + v110 + Unicode + Static + + + Application + false + v110 + true + Unicode + Static + + + + + + + + + + + + + true + $(VCInstallDir)include;..\testbench;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + $(SolutionDir)\bin\$(Configuration)\ + obj\$(Configuration)\ + + + false + $(VCInstallDir)include;..\testbench;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + $(SolutionDir)\bin\$(Configuration)\ + obj\$(Configuration)\ + + + + Use + Level3 + Disabled + WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions) + + + Windows + true + + + false + true + _DEBUG;%(PreprocessorDefinitions) + + + 0x0409 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions) + + + Windows + true + true + true + + + false + true + NDEBUG;%(PreprocessorDefinitions) + + + 0x0409 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + + + + + + + + + + + + + Create + Create + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters new file mode 100644 index 0000000..0b65204 --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters @@ -0,0 +1,63 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + + + Resource Files + + + + + Resource Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt b/Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt new file mode 100644 index 0000000..75971ad --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt @@ -0,0 +1,95 @@ +================================================================================ + MICROSOFT FOUNDATION CLASS LIBRARY : MfcTimeFliesLikeAnArrow Project Overview +=============================================================================== + +The application wizard has created this MfcTimeFliesLikeAnArrow application for +you. This application not only demonstrates the basics of using the Microsoft +Foundation Classes but is also a starting point for writing your application. + +This file contains a summary of what you will find in each of the files that +make up your MfcTimeFliesLikeAnArrow application. + +MfcTimeFliesLikeAnArrow.vcxproj + This is the main project file for VC++ projects generated using an application wizard. + It contains information about the version of Visual C++ that generated the file, and + information about the platforms, configurations, and project features selected with the + application wizard. + +MfcTimeFliesLikeAnArrow.vcxproj.filters + This is the filters file for VC++ projects generated using an Application Wizard. + It contains information about the association between the files in your project + and the filters. This association is used in the IDE to show grouping of files with + similar extensions under a specific node (for e.g. ".cpp" files are associated with the + "Source Files" filter). + +MfcTimeFliesLikeAnArrow.h + This is the main header file for the application. It includes other + project specific headers (including Resource.h) and declares the + CMfcTimeFliesLikeAnArrowApp application class. + +MfcTimeFliesLikeAnArrow.cpp + This is the main application source file that contains the application + class CMfcTimeFliesLikeAnArrowApp. + +MfcTimeFliesLikeAnArrow.rc + This is a listing of all of the Microsoft Windows resources that the + program uses. It includes the icons, bitmaps, and cursors that are stored + in the RES subdirectory. This file can be directly edited in Microsoft + Visual C++. Your project resources are in 1033. + +res\MfcTimeFliesLikeAnArrow.ico + This is an icon file, which is used as the application's icon. This + icon is included by the main resource file MfcTimeFliesLikeAnArrow.rc. + +res\MfcTimeFliesLikeAnArrow.rc2 + This file contains resources that are not edited by Microsoft + Visual C++. You should place all resources not editable by + the resource editor in this file. + +///////////////////////////////////////////////////////////////////////////// + +For the main frame window: + The project includes a standard MFC interface. + +MainFrm.h, MainFrm.cpp + These files contain the frame class CMainFrame, which is derived from + CFrameWnd and controls all SDI frame features. + +///////////////////////////////////////////////////////////////////////////// + + + +///////////////////////////////////////////////////////////////////////////// + +Other standard files: + +StdAfx.h, StdAfx.cpp + These files are used to build a precompiled header (PCH) file + named MfcTimeFliesLikeAnArrow.pch and a precompiled types file named StdAfx.obj. + +Resource.h + This is the standard header file, which defines new resource IDs. + Microsoft Visual C++ reads and updates this file. + +MfcTimeFliesLikeAnArrow.manifest + Application manifest files are used by Windows XP to describe an applications + dependency on specific versions of Side-by-Side assemblies. The loader uses this + information to load the appropriate assembly from the assembly cache or private + from the application. The Application manifest maybe included for redistribution + as an external .manifest file that is installed in the same folder as the application + executable or it may be included in the executable in the form of a resource. +///////////////////////////////////////////////////////////////////////////// + +Other notes: + +The application wizard uses "TODO:" to indicate parts of the source code you +should add to or customize. + +If your application uses MFC in a shared DLL, you will need +to redistribute the MFC DLLs. If your application is in a language +other than the operating system's locale, you will also have to +redistribute the corresponding localized resources mfc110XXX.DLL. +For more information on both of these topics, please see the section on +redistributing Visual C++ applications in MSDN documentation. + +///////////////////////////////////////////////////////////////////////////// diff --git a/Rx++/MfcTimeFliesLikeAnArrow/Resource.h b/Rx++/MfcTimeFliesLikeAnArrow/Resource.h new file mode 100644 index 0000000..f5a491a --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/Resource.h @@ -0,0 +1,20 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by MfcTimeFliesLikeAnArrow.rc +// +#define IDD_ABOUTBOX 100 +#define IDR_MAINFRAME 128 +#define IDR_MfcTimeFliesLikTYPE 130 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 310 +#define _APS_NEXT_CONTROL_VALUE 1000 +#define _APS_NEXT_SYMED_VALUE 310 +#define _APS_NEXT_COMMAND_VALUE 32771 +#endif +#endif diff --git a/Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico b/Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico new file mode 100644 index 0000000000000000000000000000000000000000..d56fbcdfdf6eac0f4727c34770c26689271d96af GIT binary patch literal 67777 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 M!Rcd=t3a*;0Hl#_rT_o{ literal 0 HcmV?d00001 diff --git a/Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp b/Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp new file mode 100644 index 0000000..4f165ae --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp @@ -0,0 +1,9 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +// stdafx.cpp : source file that includes just the standard includes +// MfcTimeFliesLikeAnArrow.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + + diff --git a/Rx++/MfcTimeFliesLikeAnArrow/stdafx.h b/Rx++/MfcTimeFliesLikeAnArrow/stdafx.h new file mode 100644 index 0000000..8b2f9dd --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/stdafx.h @@ -0,0 +1,64 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + + +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, +// but are changed infrequently + +#pragma once + +#ifndef VC_EXTRALEAN +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers +#endif + +#include "targetver.h" + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit + +// turns off MFC's hiding of some common and often safely ignored warning messages +#define _AFX_ALL_WARNINGS + +#include // MFC core and standard components +#include // MFC extensions + + + + + +#ifndef _AFX_NO_OLE_SUPPORT +#include // MFC support for Internet Explorer 4 Common Controls +#endif +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + +#include // MFC support for ribbons and control bars + + + + + + + + + +#ifdef _UNICODE +#if defined _M_IX86 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") +#elif defined _M_X64 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") +#else +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") +#endif +#endif + +// STL includes +#include +#include +#include +#include +#include +#include + +#include "rxcpp.h" + diff --git a/Rx++/MfcTimeFliesLikeAnArrow/targetver.h b/Rx++/MfcTimeFliesLikeAnArrow/targetver.h new file mode 100644 index 0000000..b447c86 --- /dev/null +++ b/Rx++/MfcTimeFliesLikeAnArrow/targetver.h @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +// Including SDKDDKVer.h defines the highest available Windows platform. + +// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and +// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. + +#include diff --git a/Rx++/RxCpp.sln b/Rx++/RxCpp.sln new file mode 100644 index 0000000..76d33c8 --- /dev/null +++ b/Rx++/RxCpp.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testbench", "testbench\testbench.vcxproj", "{6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MfcTimeFliesLikeAnArrow", "MfcTimeFliesLikeAnArrow\MfcTimeFliesLikeAnArrow.vcxproj", "{E773817F-F3E5-4E78-ADD3-B70E11F611B6}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Debug|Win32.ActiveCfg = Debug|Win32 + {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Debug|Win32.Build.0 = Debug|Win32 + {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Release|Win32.ActiveCfg = Release|Win32 + {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Release|Win32.Build.0 = Release|Win32 + {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Debug|Win32.ActiveCfg = Debug|Win32 + {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Debug|Win32.Build.0 = Debug|Win32 + {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Release|Win32.ActiveCfg = Release|Win32 + {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Rx++/license.txt b/Rx++/license.txt new file mode 100644 index 0000000..d7fd6c0 --- /dev/null +++ b/Rx++/license.txt @@ -0,0 +1,15 @@ +Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +Microsoft Open Technologies would like to thank its contributors, a list +of whom are at http://aspnetwebstack.codeplex.com/wikipage?title=Contributors. + +Licensed under the Apache License, Version 2.0 (the "License"); you +may not use this file except in compliance with the License. You may +obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied. See the License for the specific language governing permissions +and limitations under the License. \ No newline at end of file diff --git a/Rx++/testbench/rxcpp-binder.h b/Rx++/testbench/rxcpp-binder.h new file mode 100644 index 0000000..0c48e7d --- /dev/null +++ b/Rx++/testbench/rxcpp-binder.h @@ -0,0 +1,48 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +namespace rxcpp +{ + template + class Binder + { + Obj obj; + public: + Binder(Obj&& obj) : obj(std::move(obj)) + { + } + template + auto select(S selector) -> decltype(from(Select(obj, selector))) { + return from(Select(obj, selector)); + } + template + auto where(P predicate) -> decltype(from(Where(obj, predicate))) { + return from(Where(obj, predicate)); + } + template + auto take(Integral n) -> decltype(from(Take(obj, n))) { + return from(Take(obj, n)); + } + auto delay(int milliseconds) -> decltype(from(Delay(obj, milliseconds))) { + return from(Delay(obj, milliseconds)); + } + auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { + return from(LimitWindow(obj, milliseconds)); + } + auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { + return from(DistinctUntilChanged(obj)); + } + auto on_dispatcher() -> decltype(from(ObserveOnDispatcher(obj))) + { + return from(ObserveOnDispatcher(obj)); + } + template + auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { + return Subscribe(obj, onNext); + } + }; + template + Binder from(Obj&& obj) { return Binder(std::move(obj)); } + +} \ No newline at end of file diff --git a/Rx++/testbench/rxcpp.h b/Rx++/testbench/rxcpp.h new file mode 100644 index 0000000..926ae68 --- /dev/null +++ b/Rx++/testbench/rxcpp.h @@ -0,0 +1,889 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +namespace rxcpp +{ + + ////////////////////////////////////////////////////////////////////// + // + // Abstract interfaces + + template + struct Observer + { + virtual void OnNext(const T&) {}; + virtual void OnCompleted() {}; + virtual void OnError(const std::exception_ptr&) {}; + + virtual ~Observer() {} + }; + + class Disposable + { + std::function dispose; + public: + Disposable(std::function dispose) : dispose(std::move(dispose)) + { + } + void Dispose() + { + if (dispose) dispose(); + } + }; + + template + struct Observable + { + virtual Disposable Subscribe(std::shared_ptr> observer) = 0; + virtual ~Observable() {} + }; + + + + ////////////////////////////////////////////////////////////////////// + // + // constructors + + template + class CreatedObservable : public Observable + { + S subscribe; + + public: + CreatedObservable(S subscribe) : subscribe(std::move(subscribe)) + { + } + virtual Disposable Subscribe(std::shared_ptr> observer) + { + return subscribe(std::move(observer)); + } + }; + + template + std::shared_ptr> CreateObservable(S subscribe) + { + return std::make_shared>(std::move(subscribe)); + } + + template + struct CreatedObserver : public Observer + { + std::function onNext; + std::function onCompleted; + std::function onError; + + virtual void OnNext(const T& element) + { + try + { + if(onNext) + { + onNext(element); + } + } + catch (...) + { + OnError(std::current_exception()); + } + } + virtual void OnCompleted() + { + if(onCompleted) + { + onCompleted(); + clear(); + } + } + virtual void OnError(const std::exception_ptr& error) + { + if(onError) + { + onError(error); + clear(); + } + } + void clear() + { + onNext = nullptr; + onCompleted = nullptr; + onError = nullptr; + } + }; + + template + std::shared_ptr> CreateObserver( + std::function onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto p = std::make_shared>(); + p->onNext = std::move(onNext); + p->onCompleted = std::move(onCompleted); + p->onError = std::move(onError); + + return p; + } + + template + class Subject : + public Observable, + public Observer, + public std::enable_shared_from_this> + { + std::vector>> observers; + public: + virtual void OnNext(const T& element) + { + for(auto& o : observers) + { + try + { + if (o) + o->OnNext(element); + } + catch (...) + { + auto o_ = std::move(o); + o_->OnError(std::current_exception()); + } + } + } + virtual void OnCompleted() + { + for(auto& o : observers) + { + if (o) { + o->OnCompleted(); + o = nullptr; + } + } + } + virtual void OnError(const std::exception_ptr& error) + { + for(auto& o : observers) + { + if (o) { + o->OnError(error); + o = nullptr; + } + } + } + virtual Disposable Subscribe(std::shared_ptr> observer) + { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d = [wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }; + + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(std::move(observer)); + return d; + } + + private: + void RemoveObserver(std::shared_ptr> toRemove) + { + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } + }; + + template + std::shared_ptr> CreateSubject() + { + return std::make_shared>(); + } + + + ////////////////////////////////////////////////////////////////////// + // + // imperative functions + + template + Disposable Subscribe( + const std::shared_ptr>& source, + typename std::identity>::type onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto observer = CreateObserver(std::move(onNext), std::move(onCompleted), std::move(onError)); + + return source->Subscribe(observer); + } + + template + struct fix0_thunk { + F f; + fix0_thunk(F&& f) : f(std::move(f)) + { + } + void operator()() const + { + f(*this); + } + }; + template + fix0_thunk fix0(F f) + { + return fix0_thunk(std::move(f)); + } + + template + auto Range( + Integral start, Integral end = (Integral)-1, Integral step = 1 + ) + -> std::shared_ptr> + { + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Integral i; + Integral rem; + }; + auto state = std::make_shared(); + state->cancel = false; + state->i = start; + state->rem = (end - start) / step; + + DefaultScheduler::Instance().Schedule( + fix0([=](std::function self) // TODO: + { + try { + if (state->cancel) + return; + + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + ++state->i; + DefaultScheduler::Instance().Schedule(std::move(self)); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + })); + + return [=]{ state->cancel = true; }; + }); + } + + // reference handle type for a container for composing disposables + class ComposableDisposable + { + struct State + { + std::vector disposables; + std::mutex lock; + bool isDisposed; + + State() : isDisposed(false) + { + } + void Add(Disposable&& d) + { + std::unique_lock guard(lock); + if (isDisposed) { + guard.unlock(); + d.Dispose(); + } else { + disposables.push_back(std::move(d)); + } + } + void Dispose() + { + std::unique_lock guard(lock); + + isDisposed = true; + auto v = std::move(disposables); + guard.unlock(); + + std::for_each(v.begin(), v.end(), + [](Disposable& d) { d.Dispose(); }); + } + }; + + std::shared_ptr state; + + public: + ComposableDisposable() : state(new State) + { + } + void Add(Disposable d) const + { + state->Add(std::move(d)); + } + void Dispose() const + { + state->Dispose(); + } + operator Disposable() const + { + auto d = Disposable([=]{ + state->Dispose(); + }); + return d; + } + }; + + + + ////////////////////////////////////////////////////////////////////// + // + // standard query operators + + template + auto Select( + const std::shared_ptr>& source, + S selector + ) + -> const std::shared_ptr::type>> + { + typedef typename std::result_of::type U; + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + auto result = selector(element); + observer->OnNext(std::move(result)); + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + const std::shared_ptr> Where( + const std::shared_ptr>& source, + P predicate + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + auto result = predicate(element); + if (result) + { + observer->OnNext(element); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + template + std::shared_ptr> Take( + const std::shared_ptr>& source, + int n // TODO: long long? + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + { + auto remaining = std::make_shared(n); + + ComposableDisposable cd; + + auto d = Subscribe( + source, + // on next + [=](const T& element) + { + if (*remaining) + { + observer->OnNext(element); + if (--*remaining == 0) + { + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on completed + [=] + { + if (*remaining) + { + observer->OnCompleted(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + if (*remaining) + { + observer->OnError(error); + } + }); + cd.Add(std::move(d)); + return cd; + }); + } + + + + ////////////////////////////////////////////////////////////////////// + // + // time and schedulers + + struct DefaultScheduler + { + private: DefaultScheduler(const DefaultScheduler&); + public: + static DefaultScheduler& Instance() + { + // TODO: leaks. race condition on atexit though. + static DefaultScheduler* instance = new DefaultScheduler; + return *instance; + } + + typedef std::function Work; + + std::atomic trampoline; + + std::vector queue; + + std::thread worker_thread; + DefaultScheduler() : trampoline(0), shutdownRequested(false) + { + worker_thread = std::thread([=]{ worker(); }); + } + ~DefaultScheduler() + { + std::unique_lock guard(scheduleLock); + shutdownRequested = true; + guard.unlock(); + cv.notify_one(); + } + + void Schedule(Work work) + { + try { + if (++trampoline == 1) + { + work(); + + while(!queue.empty()) + { + work = std::move(queue.back()); + queue.pop_back(); + work(); + } + + } + else + { + queue.push_back(std::move(work)); + } + } + catch (...) + { + --trampoline; + throw; + } + } + + struct compare_work + { + template + bool operator()(const T& work1, const T& work2) const { + return work1.first > work2.first; + } + }; + + typedef std::chrono::steady_clock Clock; + + bool shutdownRequested; + std::mutex scheduleLock; + std::condition_variable cv; + std::priority_queue< std::pair, + std::vector>, + compare_work > scheduledWork; + + + void Schedule(int milliseconds, Work work) + { + Clock::time_point dueTime = Clock::now() + std::chrono::duration(milliseconds); + + std::unique_lock guard(scheduleLock); + bool wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; + + scheduledWork.push(std::make_pair(dueTime, std::move(work))); + + guard.unlock(); + + if (wake) + cv.notify_one(); + } + private: + void worker() + { + std::unique_lock guard(scheduleLock); + + while(!shutdownRequested) + { + + if (scheduledWork.empty()) + { + cv.wait(guard); + continue; + } + + auto now = Clock::now(); + auto dueTime = scheduledWork.top().first; + if (dueTime > now) + { + cv.wait_until(guard, dueTime); + continue; + } + + // dispatch work + auto work = std::move(scheduledWork.top().second); + scheduledWork.pop(); + + guard.unlock(); + try { + work(); + } catch (...) { + // TODO: ??? what now? + } + guard.lock(); + } + } + }; + + template + std::shared_ptr> Delay( + const std::shared_ptr>& source, + int milliseconds) + { + // TODO: for some reason, poor interactions take place if + // on_dispatcher() dispatches from UI thread. +#if 0 + if (milliseconds == 0) + return source; +#endif + + + return CreateObservable( + [=](std::shared_ptr> observer) + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ *cancel = true; })); + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + // TODO: queue + DefaultScheduler::Instance().Schedule( + milliseconds, + [=]{ + if (!*cancel) + observer->OnNext(element); + }); + }, + // on completed + [=] + { + DefaultScheduler::Instance().Schedule( + milliseconds, + [=]{ + if (!*cancel) + observer->OnCompleted(); + }); + }, + // on error + [=](const std::exception_ptr& error) + { + if (!*cancel) + observer->OnError(error); + })); + return cd; + }); + } + + // no more than one event ever 'milliseconds' + // TODO: oops, this is not the right definition for throttle. + template + std::shared_ptr> LimitWindow( + const std::shared_ptr>& source, + int milliseconds) + { + if (milliseconds == 0) + return source; + + return CreateObservable( + [=](std::shared_ptr> observer) + { + struct State { + ULONGLONG dueTime; + }; + + auto state = std::make_shared(); + state->dueTime = 0; + + return Subscribe( + source, + // on next + [=](const T& element) + { + auto now = ::GetTickCount64(); + + if (now >= state->dueTime) + { + observer->OnNext(element); + state->dueTime = now + (ULONGLONG)milliseconds; + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 + template + std::shared_ptr> DistinctUntilChanged( + const std::shared_ptr>& source) + { + return CreateObservable( + [=](std::shared_ptr> observer) + { + struct State { + T last; bool hasValue; + }; + + auto state = std::make_shared(); + state->hasValue = false; + + return Subscribe( + source, + // on next + [=](const T& element) + { + if (!state->hasValue || state->last != element) + { + observer->OnNext(element); + state->last = element; + state->hasValue = true; + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + + + + struct ObserveOnDispatcherOp + { + HWND hwnd; + + ObserveOnDispatcherOp(): hwnd(WindowClass::Instance().CreateWindow_()) + { + if (!hwnd) + throw std::exception("error"); + } + ~ObserveOnDispatcherOp() + { + // send one last message to ourselves to shutdown. + post([=]{ CloseWindow(hwnd); }); + } + + struct WindowClass + { + static const wchar_t* const className(){ return L"ObserveOnDispatcherOp::WindowClass"; } + WindowClass() + { + WNDCLASS wndclass = {}; + wndclass.style = 0; + wndclass.lpfnWndProc = &WndProc; + wndclass.cbClsExtra; + wndclass.cbWndExtra = 0; + wndclass.hInstance = NULL; + wndclass.lpszClassName = className(); + + if (!RegisterClass(&wndclass)) + throw std::exception("error"); + + } + HWND CreateWindow_() + { + return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + } + static const int WM_USER_DISPATCH = WM_USER + 1; + + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + { + switch (message) + { + // TODO: shatter attack surface. should validate the message, e.g. using a handle table. + case WM_USER_DISPATCH: + ((void(*)(void*))wParam)((void*)lParam); + return 0; + default: + return DefWindowProc(hwnd, message, wParam, lParam); + } + } + static WindowClass& Instance() { + static WindowClass instance; + return instance; + } + }; + + template + void post(Fn fn) const + { + auto p = new Fn(fn); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + } + template + static void run_proc( + void* pvfn + ) + { + auto fn = (Fn*)(void*) pvfn; + (*fn)(); + delete fn; + } + }; + + template + std::shared_ptr> ObserveOnDispatcher( + const std::shared_ptr>& source) + { + auto dispatcher = std::make_shared(); + return CreateObservable( + [=](std::shared_ptr> observer) + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + *cancel = true; + })); + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + dispatcher->post([=]{ + if (!*cancel) + observer->OnNext(element); + }); + }, + // on completed + [=] + { + dispatcher->post([=]{ + if(!*cancel) + observer->OnCompleted(); + }); + }, + // on error + [=](const std::exception_ptr& error) + { + dispatcher->post([=]{ + if (!*cancel) + observer->OnError(error); + }); + })); + return cd; + }); + } +} + +#include "rxcpp-binder.h" + +#pragma pop_macro("min") +#pragma pop_macro("max") diff --git a/Rx++/testbench/testbench.cpp b/Rx++/testbench/testbench.cpp new file mode 100644 index 0000000..ce99f97 --- /dev/null +++ b/Rx++/testbench/testbench.cpp @@ -0,0 +1,45 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +// testbench.cpp : Defines the entry point for the console application. +// + +#include "rxcpp.h" + +#include +#include + +using namespace std; + +bool IsPrime(int x); + +int main(int argc, char* argv[]) +{ + const int n = 20; + std::cout << "first " << n << " primes squared\n"; + + rxcpp::DefaultScheduler::Instance().Schedule( + [=] + { + auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values) + .where(IsPrime) + .select([](int x) { return std::make_pair(x, x*x); }) + .take(n) + .subscribe( + [](pair p) { + cout << p.first << " =square=> " << p.second << endl; + }); + }); +} + +bool IsPrime(int x) +{ + if (x < 2) return false; + for (int i = 2; i <= x/2; ++i) + { + if (x % i == 0) + return false; + } + return true; +} + diff --git a/Rx++/testbench/testbench.vcxproj b/Rx++/testbench/testbench.vcxproj new file mode 100644 index 0000000..8512615 --- /dev/null +++ b/Rx++/testbench/testbench.vcxproj @@ -0,0 +1,95 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + $(VCTargetsPath11) + + + {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB} + Win32Proj + testbench + + + + Application + true + v110 + Unicode + + + Application + false + v110 + true + Unicode + + + + + + + + + + + + + true + $(SolutionDir)\bin\$(Configuration)\ + obj\$(Configuration)\ + + + false + $(SolutionDir)\bin\$(Configuration)\ + obj\$(Configuration)\ + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + + + Console + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + + + Console + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx++/testbench/testbench.vcxproj.filters b/Rx++/testbench/testbench.vcxproj.filters new file mode 100644 index 0000000..2737526 --- /dev/null +++ b/Rx++/testbench/testbench.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Header Files + + + Header Files + + + \ No newline at end of file -- GitLab From 64e17277bfc146f97d31986cbd7a8d739693df55 Mon Sep 17 00:00:00 2001 From: claudioc Date: Tue, 6 Nov 2012 00:29:04 -0800 Subject: [PATCH 002/782] Reactive Extensions (Rx) OSS V1.0 --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 7a0a1e2..ba574dc 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,8 @@ The initial set of supported technologies is: -* Reactive Extensions: ** Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. ** RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. ** Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. * Interactive Extensions ** Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. ** IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. ** Ix++: An implantation of LINQ for Native Developers in C++ * Bindings: ** Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. ** LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. +* Reactive Extensions: + ** Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. ** RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. ** Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. * Interactive Extensions ** Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. ** IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. ** Ix++: An implantation of LINQ for Native Developers in C++ * Bindings: ** Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. ** LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. #Contributing Code Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. -- GitLab From 626b68bb2e980b7f3306517949f21744f41a2b57 Mon Sep 17 00:00:00 2001 From: clca Date: Thu, 8 Nov 2012 17:38:11 -0800 Subject: [PATCH 003/782] minor fixes to the repo structure --- AUTHORS.txt | 40 ++++++++++++++++++++++++++++++++++++++++ README.md | 45 ++++++++++++++++++++------------------------- 2 files changed, 60 insertions(+), 25 deletions(-) create mode 100644 AUTHORS.txt diff --git a/AUTHORS.txt b/AUTHORS.txt new file mode 100644 index 0000000..160efcc --- /dev/null +++ b/AUTHORS.txt @@ -0,0 +1,40 @@ +List of contributors to the Rx libraries + +Rx and Ix.NET: +Wes Dyer +Jeffrey van Gogh +Matthew Podwysocki +Bart de Smet +Danny van Velzen +Erik Meijer +Brian Beckman +Aaron Lahman +Georgi Chkodrov +Arthur Watson +Gert Drapers +Mark Shields + +Rx.js and Ix.js: +Matthew Podwysocki +Jeffrey van Gogh +Bart de Smet +Brian Beckman +Wes Dyer +Erik Meijer + +Tx: +Georgi Chkodrov +Bart de Smet +Aaron Lahman +Erik Meijer +Brian Grunkemeyer +Beysim Sezgin +Tiho Tarnavski +Collin Meek +Sajay Anthony +Karen Albrecht +John Allen +Zach Kramer + +Rx++ and Ix++: +Aaron Lahman diff --git a/README.md b/README.md index ba574dc..bb32490 100644 --- a/README.md +++ b/README.md @@ -1,25 +1,20 @@ -# Reactive Extensions Libraries - - -Tx is set of code samples showing how to use LINQ to events, such as: - -* **Real-Time standing queries:**. E.g. producing a histogram every second how many bytes were send/received over TCP per IP address. -* **Queries on past history from trace/log files:** E.g. from past trace of IIS find the slow requests by correlating "begin" and "end" events. - -The initial set of supported technologies is: - -* Event Tracing for Windows (ETW) -* Windows Event Logs -* SQL Server Extended Events (XEvent) - - - -* Reactive Extensions: - ** Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. ** RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. ** Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. * Interactive Extensions ** Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. ** IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. ** Ix++: An implantation of LINQ for Native Developers in C++ * Bindings: ** Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. ** LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. -#Contributing Code Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. - - - - - - +# Reactive Extensions: + +* Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. +* RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. +* Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. + +# Interactive Extensions +* Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. +* IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. +* Ix++: An implantation of LINQ for Native Developers in C++ + +# Applications: +* Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. +* LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. + +#Contributing Code + +Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. + +You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. \ No newline at end of file -- GitLab From 657739c1c284f34af5ae498707f06eac6b559359 Mon Sep 17 00:00:00 2001 From: clca Date: Thu, 8 Nov 2012 21:40:10 -0800 Subject: [PATCH 004/782] fixed license files --- Ix++/{license.txt.txt => license.txt} | 2 +- Ix/license.txt | 2 +- Rx++/license.txt | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) rename Ix++/{license.txt.txt => license.txt} (89%) diff --git a/Ix++/license.txt.txt b/Ix++/license.txt similarity index 89% rename from Ix++/license.txt.txt rename to Ix++/license.txt index d7fd6c0..5b47fbd 100644 --- a/Ix++/license.txt.txt +++ b/Ix++/license.txt @@ -1,6 +1,6 @@ Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. Microsoft Open Technologies would like to thank its contributors, a list -of whom are at http://aspnetwebstack.codeplex.com/wikipage?title=Contributors. +of whom are at http://rx.codeplex.com/wikipage?title=Contributors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may diff --git a/Ix/license.txt b/Ix/license.txt index d7fd6c0..5b47fbd 100644 --- a/Ix/license.txt +++ b/Ix/license.txt @@ -1,6 +1,6 @@ Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. Microsoft Open Technologies would like to thank its contributors, a list -of whom are at http://aspnetwebstack.codeplex.com/wikipage?title=Contributors. +of whom are at http://rx.codeplex.com/wikipage?title=Contributors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may diff --git a/Rx++/license.txt b/Rx++/license.txt index d7fd6c0..5b47fbd 100644 --- a/Rx++/license.txt +++ b/Rx++/license.txt @@ -1,6 +1,6 @@ Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. Microsoft Open Technologies would like to thank its contributors, a list -of whom are at http://aspnetwebstack.codeplex.com/wikipage?title=Contributors. +of whom are at http://rx.codeplex.com/wikipage?title=Contributors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may -- GitLab From 5b8fbf85feb1cf5fdd15ee852b66497df6df01f4 Mon Sep 17 00:00:00 2001 From: "Scott Blomquist (MS OPEN TECH)" Date: Sat, 10 Nov 2012 23:06:25 -0800 Subject: [PATCH 005/782] Fix to work with empty STL containers --- Ix++/src/cpplinq/linq.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Ix++/src/cpplinq/linq.hpp b/Ix++/src/cpplinq/linq.hpp index 64cf8fb..1070331 100644 --- a/Ix++/src/cpplinq/linq.hpp +++ b/Ix++/src/cpplinq/linq.hpp @@ -475,7 +475,7 @@ public: // -------------------- container/range methods -------------------- - iterator begin() const { return iterator(c.get_cursor()); } + iterator begin() const { auto cur = c.get_cursor(); return !cur.empty() ? iterator(cur) : iterator(); } iterator end() const { return iterator(); } linq_driver& operator=(const linq_driver& other) { c = other.c; return *this; } template -- GitLab From d584db7745c65d8336f4c1860aa6a2c57a209695 Mon Sep 17 00:00:00 2001 From: "Scott Blomquist (MS OPEN TECH)" Date: Sat, 10 Nov 2012 23:40:35 -0800 Subject: [PATCH 006/782] Fix Ix++ unittest paths Note: To build the Ix++ unit tests, use nmake.exe from your Visual Studio tools path. You'll need the BOOST environment variable point to a recent set of boost libs. --- Ix++/unittest/makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Ix++/unittest/makefile b/Ix++/unittest/makefile index c839943..4fea142 100644 --- a/Ix++/unittest/makefile +++ b/Ix++/unittest/makefile @@ -9,7 +9,7 @@ O=..\..\bin\$(Config) !message Building ===== $(Config) ===== program=testbench.exe -INCLUDE=$(INCLUDE);../ +INCLUDE=$(INCLUDE);../src !if "$(Config)"=="Debug" OPTIONS=/Od @@ -27,7 +27,7 @@ all : "$O/$(program)" $O : mkdir $O -"$O/$(program)" : testbench.cpp testbench.hpp ../cpplinq/*.hpp $O +"$O/$(program)" : testbench.cpp testbench.hpp ../src/cpplinq/*.hpp $O $(CPP) $(OPTIONS) /EHsc /Zi /Fe"$@" /Fo$O/ testbench.cpp clean : -- GitLab From 6aa4590ea5952d3ba5e1f99b6ede76d856f88617 Mon Sep 17 00:00:00 2001 From: georgis Date: Wed, 16 Jan 2013 14:02:54 -0800 Subject: [PATCH 007/782] removing the Tx code (it is now on http://tx.codeplex.com) --- .gitignore | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a8e354f --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +[Oo]bj +[Bb]in +TestResults +*.user +*.suo +*.[Cc]ache +*.bak +*.ncb \ No newline at end of file -- GitLab From a0f2bbe9acce9483163de730341cf89ec0331d2b Mon Sep 17 00:00:00 2001 From: Scott Blomquist Date: Thu, 17 Jan 2013 17:48:09 -0800 Subject: [PATCH 008/782] New directory structure. --- .gitignore | 8 - {Ix++ => Ix/CPP}/.gitignore | 0 {Ix++ => Ix/CPP}/license.txt | 0 {Ix++ => Ix/CPP}/projects/CppLinq.vpj | 0 {Ix++ => Ix/CPP}/projects/CppLinq.vpw | 0 .../CPP}/projects/Unittest.CppLinq.vpj | 0 .../samples/SampleCppLinq/SampleCppLinq.cpp | 0 .../samples/SampleCppLinq/SampleCppLinq.sln | 0 .../SampleCppLinq/SampleCppLinq.vcxproj | 0 .../SampleCppLinq.vcxproj.filters | 0 .../CPP}/samples/SampleCppLinq/data.txt | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_cursor.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_groupby.hpp | 0 .../CPP}/src/cpplinq/linq_iterators.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_last.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_select.hpp | 0 .../CPP}/src/cpplinq/linq_selectmany.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_skip.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_take.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/linq_where.hpp | 0 {Ix++ => Ix/CPP}/src/cpplinq/util.hpp | 0 {Ix++ => Ix/CPP}/unittest/makefile | 0 {Ix++ => Ix/CPP}/unittest/testbench.cpp | 0 {Ix++ => Ix/CPP}/unittest/testbench.hpp | 0 Ix/Common.targets | 180 -- Ix/Import.targets | 16 - Ix/Interactive Extensions.sln | 332 --- Ix/Interactive Extensions.vsmdi | 6 - Ix/Interactive Extensions.vssscc | 10 - Ix/Local.testsettings | 37 - .../AsyncEnumerable.Aggregates.cs | 2019 -------------- .../AsyncEnumerable.Conversions.cs | 262 -- .../AsyncEnumerable.Creation.cs | 283 -- .../AsyncEnumerable.Exceptions.cs | 381 --- .../AsyncEnumerable.Generated.cs | 1250 --------- .../AsyncEnumerable.Multiple.cs | 755 ----- .../AsyncEnumerable.Single.cs | 2466 ----------------- .../AsyncEnumerator.cs | 26 - Ix/System.Interactive.Async/Disposables.cs | 89 - .../EnumerableGrouping.cs | 34 - .../IAsyncEnumerable.cs | 23 - .../IAsyncEnumerator.cs | 34 - Ix/System.Interactive.Async/IAsyncGrouping.cs | 19 - .../IOrderedAsyncEnumerable.cs | 15 - .../Properties/AssemblyInfo.cs | 37 - .../System.Interactive.Async.csproj | 47 - Ix/System.Interactive.Async/TaskExt.cs | 134 - .../Properties/AssemblyInfo.cs | 37 - .../QueryableEx.cs | 2327 ---------------- .../System.Interactive.Providers.csproj | 41 - .../EnumerableEx.Aggregates.cs | 173 -- .../EnumerableEx.Buffering.cs | 647 ----- .../EnumerableEx.Creation.cs | 173 -- .../EnumerableEx.Exceptions.cs | 284 -- .../EnumerableEx.Imperative.cs | 156 -- .../EnumerableEx.Multiple.cs | 96 - Ix/System.Interactive/EnumerableEx.Single.cs | 672 ----- .../Properties/AssemblyInfo.cs | 37 - .../System.Interactive.csproj | 41 - Ix/Tests/App.cs | 47 - Ix/Tests/AsyncTests.Aggregates.cs | 2168 --------------- Ix/Tests/AsyncTests.Bugs.cs | 266 -- Ix/Tests/AsyncTests.Conversions.cs | 312 --- Ix/Tests/AsyncTests.Creation.cs | 409 --- Ix/Tests/AsyncTests.Exceptions.cs | 551 ---- Ix/Tests/AsyncTests.Multiple.cs | 787 ------ Ix/Tests/AsyncTests.Single.cs | 2455 ---------------- Ix/Tests/AsyncTests.cs | 54 - Ix/Tests/Properties/AppManifest.xml | 7 - Ix/Tests/Properties/AssemblyInfo.cs | 35 - Ix/Tests/Tests.Aggregates.cs | 118 - Ix/Tests/Tests.Buffering.cs | 625 ----- Ix/Tests/Tests.Creation.cs | 224 -- Ix/Tests/Tests.Exceptions.cs | 311 --- Ix/Tests/Tests.Imperative.cs | 180 -- Ix/Tests/Tests.Multiple.cs | 74 - Ix/Tests/Tests.Qbservable.cs | 139 - Ix/Tests/Tests.Single.cs | 431 --- Ix/Tests/Tests.cs | 51 - Ix/Tests/Tests.csproj | 91 - Ix/TraceAndTestImpact.testsettings | 21 - Rx++/.gitattributes | 22 - Rx++/.gitignore | 163 -- Rx++/license.txt | 15 - {Ix => Rx/CPP}/.gitattributes | 0 {Ix => Rx/CPP}/.gitignore | 0 .../CPP}/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 0 .../CPP}/MfcTimeFliesLikeAnArrow/MainFrm.h | 0 .../MfcTimeFliesLikeAnArrow.cpp | 0 .../MfcTimeFliesLikeAnArrow.h | 0 .../MfcTimeFliesLikeAnArrow.rc | 0 .../MfcTimeFliesLikeAnArrow.vcxproj | 0 .../MfcTimeFliesLikeAnArrow.vcxproj.filters | 0 .../CPP}/MfcTimeFliesLikeAnArrow/ReadMe.txt | 0 .../CPP}/MfcTimeFliesLikeAnArrow/Resource.h | 0 .../res/MfcTimeFliesLikeAnArrow.ico | Bin .../res/MfcTimeFliesLikeAnArrow.rc2 | Bin .../CPP}/MfcTimeFliesLikeAnArrow/stdafx.cpp | 0 .../CPP}/MfcTimeFliesLikeAnArrow/stdafx.h | 0 .../CPP}/MfcTimeFliesLikeAnArrow/targetver.h | 0 {Rx++ => Rx/CPP}/RxCpp.sln | 0 {Ix => Rx/CPP}/license.txt | 0 {Rx++ => Rx/CPP}/testbench/rxcpp-binder.h | 0 {Rx++ => Rx/CPP}/testbench/rxcpp.h | 0 {Rx++ => Rx/CPP}/testbench/testbench.cpp | 0 {Rx++ => Rx/CPP}/testbench/testbench.vcxproj | 0 .../CPP}/testbench/testbench.vcxproj.filters | 0 108 files changed, 22703 deletions(-) delete mode 100644 .gitignore rename {Ix++ => Ix/CPP}/.gitignore (100%) rename {Ix++ => Ix/CPP}/license.txt (100%) rename {Ix++ => Ix/CPP}/projects/CppLinq.vpj (100%) rename {Ix++ => Ix/CPP}/projects/CppLinq.vpw (100%) rename {Ix++ => Ix/CPP}/projects/Unittest.CppLinq.vpj (100%) rename {Ix++ => Ix/CPP}/samples/SampleCppLinq/SampleCppLinq.cpp (100%) rename {Ix++ => Ix/CPP}/samples/SampleCppLinq/SampleCppLinq.sln (100%) rename {Ix++ => Ix/CPP}/samples/SampleCppLinq/SampleCppLinq.vcxproj (100%) rename {Ix++ => Ix/CPP}/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters (100%) rename {Ix++ => Ix/CPP}/samples/SampleCppLinq/data.txt (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_cursor.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_groupby.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_iterators.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_last.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_select.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_selectmany.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_skip.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_take.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/linq_where.hpp (100%) rename {Ix++ => Ix/CPP}/src/cpplinq/util.hpp (100%) rename {Ix++ => Ix/CPP}/unittest/makefile (100%) rename {Ix++ => Ix/CPP}/unittest/testbench.cpp (100%) rename {Ix++ => Ix/CPP}/unittest/testbench.hpp (100%) delete mode 100644 Ix/Common.targets delete mode 100644 Ix/Import.targets delete mode 100644 Ix/Interactive Extensions.sln delete mode 100644 Ix/Interactive Extensions.vsmdi delete mode 100644 Ix/Interactive Extensions.vssscc delete mode 100644 Ix/Local.testsettings delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerable.Single.cs delete mode 100644 Ix/System.Interactive.Async/AsyncEnumerator.cs delete mode 100644 Ix/System.Interactive.Async/Disposables.cs delete mode 100644 Ix/System.Interactive.Async/EnumerableGrouping.cs delete mode 100644 Ix/System.Interactive.Async/IAsyncEnumerable.cs delete mode 100644 Ix/System.Interactive.Async/IAsyncEnumerator.cs delete mode 100644 Ix/System.Interactive.Async/IAsyncGrouping.cs delete mode 100644 Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs delete mode 100644 Ix/System.Interactive.Async/Properties/AssemblyInfo.cs delete mode 100644 Ix/System.Interactive.Async/System.Interactive.Async.csproj delete mode 100644 Ix/System.Interactive.Async/TaskExt.cs delete mode 100644 Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs delete mode 100644 Ix/System.Interactive.Providers/QueryableEx.cs delete mode 100644 Ix/System.Interactive.Providers/System.Interactive.Providers.csproj delete mode 100644 Ix/System.Interactive/EnumerableEx.Aggregates.cs delete mode 100644 Ix/System.Interactive/EnumerableEx.Buffering.cs delete mode 100644 Ix/System.Interactive/EnumerableEx.Creation.cs delete mode 100644 Ix/System.Interactive/EnumerableEx.Exceptions.cs delete mode 100644 Ix/System.Interactive/EnumerableEx.Imperative.cs delete mode 100644 Ix/System.Interactive/EnumerableEx.Multiple.cs delete mode 100644 Ix/System.Interactive/EnumerableEx.Single.cs delete mode 100644 Ix/System.Interactive/Properties/AssemblyInfo.cs delete mode 100644 Ix/System.Interactive/System.Interactive.csproj delete mode 100644 Ix/Tests/App.cs delete mode 100644 Ix/Tests/AsyncTests.Aggregates.cs delete mode 100644 Ix/Tests/AsyncTests.Bugs.cs delete mode 100644 Ix/Tests/AsyncTests.Conversions.cs delete mode 100644 Ix/Tests/AsyncTests.Creation.cs delete mode 100644 Ix/Tests/AsyncTests.Exceptions.cs delete mode 100644 Ix/Tests/AsyncTests.Multiple.cs delete mode 100644 Ix/Tests/AsyncTests.Single.cs delete mode 100644 Ix/Tests/AsyncTests.cs delete mode 100644 Ix/Tests/Properties/AppManifest.xml delete mode 100644 Ix/Tests/Properties/AssemblyInfo.cs delete mode 100644 Ix/Tests/Tests.Aggregates.cs delete mode 100644 Ix/Tests/Tests.Buffering.cs delete mode 100644 Ix/Tests/Tests.Creation.cs delete mode 100644 Ix/Tests/Tests.Exceptions.cs delete mode 100644 Ix/Tests/Tests.Imperative.cs delete mode 100644 Ix/Tests/Tests.Multiple.cs delete mode 100644 Ix/Tests/Tests.Qbservable.cs delete mode 100644 Ix/Tests/Tests.Single.cs delete mode 100644 Ix/Tests/Tests.cs delete mode 100644 Ix/Tests/Tests.csproj delete mode 100644 Ix/TraceAndTestImpact.testsettings delete mode 100644 Rx++/.gitattributes delete mode 100644 Rx++/.gitignore delete mode 100644 Rx++/license.txt rename {Ix => Rx/CPP}/.gitattributes (100%) rename {Ix => Rx/CPP}/.gitignore (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MainFrm.cpp (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MainFrm.h (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/ReadMe.txt (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/Resource.h (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/stdafx.cpp (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/stdafx.h (100%) rename {Rx++ => Rx/CPP}/MfcTimeFliesLikeAnArrow/targetver.h (100%) rename {Rx++ => Rx/CPP}/RxCpp.sln (100%) rename {Ix => Rx/CPP}/license.txt (100%) rename {Rx++ => Rx/CPP}/testbench/rxcpp-binder.h (100%) rename {Rx++ => Rx/CPP}/testbench/rxcpp.h (100%) rename {Rx++ => Rx/CPP}/testbench/testbench.cpp (100%) rename {Rx++ => Rx/CPP}/testbench/testbench.vcxproj (100%) rename {Rx++ => Rx/CPP}/testbench/testbench.vcxproj.filters (100%) diff --git a/.gitignore b/.gitignore deleted file mode 100644 index a8e354f..0000000 --- a/.gitignore +++ /dev/null @@ -1,8 +0,0 @@ -[Oo]bj -[Bb]in -TestResults -*.user -*.suo -*.[Cc]ache -*.bak -*.ncb \ No newline at end of file diff --git a/Ix++/.gitignore b/Ix/CPP/.gitignore similarity index 100% rename from Ix++/.gitignore rename to Ix/CPP/.gitignore diff --git a/Ix++/license.txt b/Ix/CPP/license.txt similarity index 100% rename from Ix++/license.txt rename to Ix/CPP/license.txt diff --git a/Ix++/projects/CppLinq.vpj b/Ix/CPP/projects/CppLinq.vpj similarity index 100% rename from Ix++/projects/CppLinq.vpj rename to Ix/CPP/projects/CppLinq.vpj diff --git a/Ix++/projects/CppLinq.vpw b/Ix/CPP/projects/CppLinq.vpw similarity index 100% rename from Ix++/projects/CppLinq.vpw rename to Ix/CPP/projects/CppLinq.vpw diff --git a/Ix++/projects/Unittest.CppLinq.vpj b/Ix/CPP/projects/Unittest.CppLinq.vpj similarity index 100% rename from Ix++/projects/Unittest.CppLinq.vpj rename to Ix/CPP/projects/Unittest.CppLinq.vpj diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.cpp b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp similarity index 100% rename from Ix++/samples/SampleCppLinq/SampleCppLinq.cpp rename to Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.sln b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.sln similarity index 100% rename from Ix++/samples/SampleCppLinq/SampleCppLinq.sln rename to Ix/CPP/samples/SampleCppLinq/SampleCppLinq.sln diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.vcxproj similarity index 100% rename from Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj rename to Ix/CPP/samples/SampleCppLinq/SampleCppLinq.vcxproj diff --git a/Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters similarity index 100% rename from Ix++/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters rename to Ix/CPP/samples/SampleCppLinq/SampleCppLinq.vcxproj.filters diff --git a/Ix++/samples/SampleCppLinq/data.txt b/Ix/CPP/samples/SampleCppLinq/data.txt similarity index 100% rename from Ix++/samples/SampleCppLinq/data.txt rename to Ix/CPP/samples/SampleCppLinq/data.txt diff --git a/Ix++/src/cpplinq/linq.hpp b/Ix/CPP/src/cpplinq/linq.hpp similarity index 100% rename from Ix++/src/cpplinq/linq.hpp rename to Ix/CPP/src/cpplinq/linq.hpp diff --git a/Ix++/src/cpplinq/linq_cursor.hpp b/Ix/CPP/src/cpplinq/linq_cursor.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_cursor.hpp rename to Ix/CPP/src/cpplinq/linq_cursor.hpp diff --git a/Ix++/src/cpplinq/linq_groupby.hpp b/Ix/CPP/src/cpplinq/linq_groupby.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_groupby.hpp rename to Ix/CPP/src/cpplinq/linq_groupby.hpp diff --git a/Ix++/src/cpplinq/linq_iterators.hpp b/Ix/CPP/src/cpplinq/linq_iterators.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_iterators.hpp rename to Ix/CPP/src/cpplinq/linq_iterators.hpp diff --git a/Ix++/src/cpplinq/linq_last.hpp b/Ix/CPP/src/cpplinq/linq_last.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_last.hpp rename to Ix/CPP/src/cpplinq/linq_last.hpp diff --git a/Ix++/src/cpplinq/linq_select.hpp b/Ix/CPP/src/cpplinq/linq_select.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_select.hpp rename to Ix/CPP/src/cpplinq/linq_select.hpp diff --git a/Ix++/src/cpplinq/linq_selectmany.hpp b/Ix/CPP/src/cpplinq/linq_selectmany.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_selectmany.hpp rename to Ix/CPP/src/cpplinq/linq_selectmany.hpp diff --git a/Ix++/src/cpplinq/linq_skip.hpp b/Ix/CPP/src/cpplinq/linq_skip.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_skip.hpp rename to Ix/CPP/src/cpplinq/linq_skip.hpp diff --git a/Ix++/src/cpplinq/linq_take.hpp b/Ix/CPP/src/cpplinq/linq_take.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_take.hpp rename to Ix/CPP/src/cpplinq/linq_take.hpp diff --git a/Ix++/src/cpplinq/linq_where.hpp b/Ix/CPP/src/cpplinq/linq_where.hpp similarity index 100% rename from Ix++/src/cpplinq/linq_where.hpp rename to Ix/CPP/src/cpplinq/linq_where.hpp diff --git a/Ix++/src/cpplinq/util.hpp b/Ix/CPP/src/cpplinq/util.hpp similarity index 100% rename from Ix++/src/cpplinq/util.hpp rename to Ix/CPP/src/cpplinq/util.hpp diff --git a/Ix++/unittest/makefile b/Ix/CPP/unittest/makefile similarity index 100% rename from Ix++/unittest/makefile rename to Ix/CPP/unittest/makefile diff --git a/Ix++/unittest/testbench.cpp b/Ix/CPP/unittest/testbench.cpp similarity index 100% rename from Ix++/unittest/testbench.cpp rename to Ix/CPP/unittest/testbench.cpp diff --git a/Ix++/unittest/testbench.hpp b/Ix/CPP/unittest/testbench.hpp similarity index 100% rename from Ix++/unittest/testbench.hpp rename to Ix/CPP/unittest/testbench.hpp diff --git a/Ix/Common.targets b/Ix/Common.targets deleted file mode 100644 index 032880f..0000000 --- a/Ix/Common.targets +++ /dev/null @@ -1,180 +0,0 @@ - - - - - AnyCPU - 8.0.30703 - 2.0 - - - - - true - full - false - bin\Debug40\ - $(DefineConstants);TRACE;DEBUG - prompt - 4 - v4.0 - DESKTOPCLR - DESKTOPCLR40 - - - pdbonly - true - bin\Release40\ - $(DefineConstants);TRACE - prompt - 4 - v4.0 - DESKTOPCLR - DESKTOPCLR40 - - - - true - full - false - bin\Debug35\ - $(DefineConstants);TRACE;DEBUG;NO_VARIANCE;NO_TPL;NO_LARGEARITY;NO_RXINTERFACES;NO_ZIP - prompt - 4 - v3.5 - DESKTOPCLR - DESKTOPCLR20 - - - pdbonly - true - bin\Release35\ - $(DefineConstants);TRACE;NO_VARIANCE;NO_TPL;NO_LARGEARITY;NO_RXINTERFACES;NO_ZIP - prompt - 4 - v3.5 - DESKTOPCLR - DESKTOPCLR20 - - - - true - full - false - bin\DebugSL4\ - $(DefineConstants);TRACE;DEBUG;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES - prompt - 4 - Silverlight - v4.0 - $(TargetFrameworkVersion) - false - SILVERLIGHT - SILVERLIGHT4 - - - pdbonly - true - bin\ReleaseSL4\ - $(DefineConstants);TRACE;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES - prompt - 4 - Silverlight - v4.0 - $(TargetFrameworkVersion) - false - SILVERLIGHT - SILVERLIGHT4 - - - true - full - false - bin\DebugSL5\ - $(DefineConstants);TRACE;DEBUG;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES - prompt - 4 - Silverlight - v5.0 - $(TargetFrameworkVersion) - false - SILVERLIGHT - SILVERLIGHT5 - - - pdbonly - true - bin\ReleaseSL5\ - $(DefineConstants);TRACE;NO_SERIALIZABLE;NO_TPL;NO_REMOTING;NO_SEMAPHORE;NO_RXINTERFACES - prompt - 4 - Silverlight - v5.0 - $(TargetFrameworkVersion) - false - SILVERLIGHT - SILVERLIGHT5 - - - - true - full - false - bin\DebugWP7\ - $(DefineConstants);TRACE;DEBUG;WINDOWSPHONE7;NO_TLS;NO_VARIANCE;NO_SERIALIZABLE;NO_TPL;NO_HASHSET;NO_REMOTING;NO_SEMAPHORE;NO_LARGEARITY;NO_ZIP - prompt - 4 - WindowsPhone - Silverlight - v4.0 - $(TargetFrameworkVersion) - false - SILVERLIGHT - SILVERLIGHTM7 - - - pdbonly - true - bin\ReleaseWP7\ - $(DefineConstants);TRACE;WINDOWSPHONE7;NO_TLS;NO_VARIANCE;NO_SERIALIZABLE;NO_TPL;NO_HASHSET;NO_REMOTING;NO_SEMAPHORE;NO_LARGEARITY;NO_ZIP - prompt - 4 - WindowsPhone - Silverlight - v4.0 - $(TargetFrameworkVersion) - false - SILVERLIGHT - SILVERLIGHTM7 - - - - $(DefineConstants);$(BuildPlatform);$(BuildFlavor) - - - - $(DefineConstants);STABLE - - - - $(DefineConstants);SIGNED - true - ..\35MSSharedLib1024.snk - true - - - - $(DefineConstants);NO_CODECOVERAGE - - - - CP_SetBuildReferencePath - - - - $(ProjectDir)..\..\..\References\$(BuildFlavor) - - - - \ No newline at end of file diff --git a/Ix/Import.targets b/Ix/Import.targets deleted file mode 100644 index fb23483..0000000 --- a/Ix/Import.targets +++ /dev/null @@ -1,16 +0,0 @@ - - - - - - - - - - - - - - - - diff --git a/Ix/Interactive Extensions.sln b/Ix/Interactive Extensions.sln deleted file mode 100644 index 5fbfed0..0000000 --- a/Ix/Interactive Extensions.sln +++ /dev/null @@ -1,332 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 2012 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Interactive", "System.Interactive\System.Interactive.csproj", "{8E4B04F0-915E-48F9-9796-76278C6094BD}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{C4C8532A-F8D2-428B-962E-FD578A1E647C}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{01E445E3-2296-48ED-A70D-F64CE755E0B6}" - ProjectSection(SolutionItems) = preProject - Interactive Extensions.vsmdi = Interactive Extensions.vsmdi - Local.testsettings = Local.testsettings - TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings - EndProjectSection -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Interactive.Providers", "System.Interactive.Providers\System.Interactive.Providers.csproj", "{6D62E966-469D-4A99-BD43-0A17FA14FB4F}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Interactive.Async", "System.Interactive.Async\System.Interactive.Async.csproj", "{7269A578-326A-4C3E-9874-A2D2600095BC}" -EndProject -Global - GlobalSection(TestCaseManagementSettings) = postSolution - CategoryFile = Interactive Extensions.vsmdi - EndGlobalSection - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Debug|Mixed Platforms = Debug|Mixed Platforms - Debug|x86 = Debug|x86 - Debug35|Any CPU = Debug35|Any CPU - Debug35|Mixed Platforms = Debug35|Mixed Platforms - Debug35|x86 = Debug35|x86 - Debug40|Any CPU = Debug40|Any CPU - Debug40|Mixed Platforms = Debug40|Mixed Platforms - Debug40|x86 = Debug40|x86 - DebugPL|Any CPU = DebugPL|Any CPU - DebugPL|Mixed Platforms = DebugPL|Mixed Platforms - DebugPL|x86 = DebugPL|x86 - DebugSL4|Any CPU = DebugSL4|Any CPU - DebugSL4|Mixed Platforms = DebugSL4|Mixed Platforms - DebugSL4|x86 = DebugSL4|x86 - DebugSL5|Any CPU = DebugSL5|Any CPU - DebugSL5|Mixed Platforms = DebugSL5|Mixed Platforms - DebugSL5|x86 = DebugSL5|x86 - DebugWP7|Any CPU = DebugWP7|Any CPU - DebugWP7|Mixed Platforms = DebugWP7|Mixed Platforms - DebugWP7|x86 = DebugWP7|x86 - Release|Any CPU = Release|Any CPU - Release|Mixed Platforms = Release|Mixed Platforms - Release|x86 = Release|x86 - Release35|Any CPU = Release35|Any CPU - Release35|Mixed Platforms = Release35|Mixed Platforms - Release35|x86 = Release35|x86 - Release40|Any CPU = Release40|Any CPU - Release40|Mixed Platforms = Release40|Mixed Platforms - Release40|x86 = Release40|x86 - ReleasePL|Any CPU = ReleasePL|Any CPU - ReleasePL|Mixed Platforms = ReleasePL|Mixed Platforms - ReleasePL|x86 = ReleasePL|x86 - ReleaseSL4|Any CPU = ReleaseSL4|Any CPU - ReleaseSL4|Mixed Platforms = ReleaseSL4|Mixed Platforms - ReleaseSL4|x86 = ReleaseSL4|x86 - ReleaseSL5|Any CPU = ReleaseSL5|Any CPU - ReleaseSL5|Mixed Platforms = ReleaseSL5|Mixed Platforms - ReleaseSL5|x86 = ReleaseSL5|x86 - ReleaseWP7|Any CPU = ReleaseWP7|Any CPU - ReleaseWP7|Mixed Platforms = ReleaseWP7|Mixed Platforms - ReleaseWP7|x86 = ReleaseWP7|x86 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Any CPU.ActiveCfg = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Any CPU.Build.0 = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Mixed Platforms.ActiveCfg = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|Mixed Platforms.Build.0 = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug|x86.ActiveCfg = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Any CPU.Build.0 = Debug35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|Mixed Platforms.Build.0 = Debug35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug35|x86.ActiveCfg = Debug35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Any CPU.Build.0 = Debug40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Debug40|x86.ActiveCfg = Debug40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Any CPU.ActiveCfg = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Any CPU.Build.0 = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Mixed Platforms.ActiveCfg = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|Mixed Platforms.Build.0 = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugPL|x86.ActiveCfg = DebugPL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Any CPU.Build.0 = DebugSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|Mixed Platforms.Build.0 = DebugSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Any CPU.Build.0 = DebugSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|Mixed Platforms.Build.0 = DebugSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Any CPU.Build.0 = DebugWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|Mixed Platforms.Build.0 = DebugWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Any CPU.ActiveCfg = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Any CPU.Build.0 = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|Mixed Platforms.Build.0 = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release|x86.ActiveCfg = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Any CPU.ActiveCfg = Release35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Any CPU.Build.0 = Release35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|Mixed Platforms.Build.0 = Release35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release35|x86.ActiveCfg = Release35|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Any CPU.ActiveCfg = Release40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Any CPU.Build.0 = Release40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.Release40|x86.ActiveCfg = Release40|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Any CPU.ActiveCfg = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Any CPU.Build.0 = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|Mixed Platforms.Build.0 = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleasePL|x86.ActiveCfg = ReleasePL|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Any CPU.Build.0 = ReleaseSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|Mixed Platforms.Build.0 = ReleaseSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Any CPU.Build.0 = ReleaseSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|Mixed Platforms.Build.0 = ReleaseSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Any CPU.Build.0 = ReleaseWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU - {8E4B04F0-915E-48F9-9796-76278C6094BD}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Any CPU.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Any CPU.Build.0 = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|Mixed Platforms.Build.0 = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug|x86.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Any CPU.Build.0 = Debug35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|Mixed Platforms.Build.0 = Debug35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug35|x86.ActiveCfg = Debug35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Any CPU.Build.0 = Debug40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Debug40|x86.ActiveCfg = Debug40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Any CPU.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Any CPU.Build.0 = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|Mixed Platforms.Build.0 = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugPL|x86.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Any CPU.Build.0 = DebugSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|Mixed Platforms.Build.0 = DebugSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Any CPU.Build.0 = DebugSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|Mixed Platforms.Build.0 = DebugSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Any CPU.Build.0 = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|Mixed Platforms.Build.0 = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Any CPU.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Any CPU.Build.0 = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release|x86.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Any CPU.ActiveCfg = Release35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Any CPU.Build.0 = Release35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|Mixed Platforms.Build.0 = Release35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release35|x86.ActiveCfg = Release35|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Any CPU.ActiveCfg = Release40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Any CPU.Build.0 = Release40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.Release40|x86.ActiveCfg = Release40|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Any CPU.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Any CPU.Build.0 = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleasePL|x86.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Any CPU.Build.0 = ReleaseSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|Mixed Platforms.Build.0 = ReleaseSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Any CPU.Build.0 = ReleaseSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|Mixed Platforms.Build.0 = ReleaseSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Any CPU.Build.0 = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|Mixed Platforms.Build.0 = ReleaseWP7|Any CPU - {C4C8532A-F8D2-428B-962E-FD578A1E647C}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Any CPU.ActiveCfg = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Any CPU.Build.0 = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Mixed Platforms.ActiveCfg = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|Mixed Platforms.Build.0 = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug|x86.ActiveCfg = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Any CPU.Build.0 = Debug35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|Mixed Platforms.Build.0 = Debug35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug35|x86.ActiveCfg = Debug35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Any CPU.Build.0 = Debug40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Debug40|x86.ActiveCfg = Debug40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Any CPU.ActiveCfg = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Any CPU.Build.0 = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Mixed Platforms.ActiveCfg = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|Mixed Platforms.Build.0 = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugPL|x86.ActiveCfg = DebugPL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Any CPU.Build.0 = DebugSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|Mixed Platforms.Build.0 = DebugSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Any CPU.Build.0 = DebugSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|Mixed Platforms.Build.0 = DebugSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Any CPU.ActiveCfg = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Any CPU.Build.0 = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|Mixed Platforms.Build.0 = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release|x86.ActiveCfg = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Any CPU.ActiveCfg = Release35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Any CPU.Build.0 = Release35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|Mixed Platforms.Build.0 = Release35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release35|x86.ActiveCfg = Release35|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Any CPU.ActiveCfg = Release40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Any CPU.Build.0 = Release40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.Release40|x86.ActiveCfg = Release40|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Any CPU.ActiveCfg = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Any CPU.Build.0 = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|Mixed Platforms.Build.0 = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleasePL|x86.ActiveCfg = ReleasePL|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Any CPU.Build.0 = ReleaseSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|Mixed Platforms.Build.0 = ReleaseSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Any CPU.Build.0 = ReleaseSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|Mixed Platforms.Build.0 = ReleaseSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU - {6D62E966-469D-4A99-BD43-0A17FA14FB4F}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Any CPU.ActiveCfg = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Any CPU.Build.0 = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Mixed Platforms.ActiveCfg = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|Mixed Platforms.Build.0 = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug|x86.ActiveCfg = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug35|Any CPU.ActiveCfg = Debug35|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug35|Mixed Platforms.ActiveCfg = Debug35|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug35|x86.ActiveCfg = Debug35|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Any CPU.ActiveCfg = Debug40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Any CPU.Build.0 = Debug40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Mixed Platforms.ActiveCfg = Debug40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|Mixed Platforms.Build.0 = Debug40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Debug40|x86.ActiveCfg = Debug40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Any CPU.ActiveCfg = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Any CPU.Build.0 = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Mixed Platforms.ActiveCfg = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|Mixed Platforms.Build.0 = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugPL|x86.ActiveCfg = DebugPL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL4|Any CPU.ActiveCfg = DebugSL4|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL4|Mixed Platforms.ActiveCfg = DebugSL4|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL4|x86.ActiveCfg = DebugSL4|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL5|Any CPU.ActiveCfg = DebugSL5|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL5|Mixed Platforms.ActiveCfg = DebugSL5|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugSL5|x86.ActiveCfg = DebugSL5|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugWP7|Any CPU.ActiveCfg = DebugWP7|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugWP7|Mixed Platforms.ActiveCfg = DebugWP7|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.DebugWP7|x86.ActiveCfg = DebugWP7|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Any CPU.ActiveCfg = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Any CPU.Build.0 = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|Mixed Platforms.Build.0 = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release|x86.ActiveCfg = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release35|Any CPU.ActiveCfg = Release35|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release35|Mixed Platforms.ActiveCfg = Release35|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release35|x86.ActiveCfg = Release35|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Any CPU.ActiveCfg = Release40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Any CPU.Build.0 = Release40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Mixed Platforms.ActiveCfg = Release40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|Mixed Platforms.Build.0 = Release40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.Release40|x86.ActiveCfg = Release40|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Any CPU.ActiveCfg = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Any CPU.Build.0 = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Mixed Platforms.ActiveCfg = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|Mixed Platforms.Build.0 = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleasePL|x86.ActiveCfg = ReleasePL|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL4|Any CPU.ActiveCfg = ReleaseSL4|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL4|Mixed Platforms.ActiveCfg = ReleaseSL4|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL4|x86.ActiveCfg = ReleaseSL4|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL5|Any CPU.ActiveCfg = ReleaseSL5|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL5|Mixed Platforms.ActiveCfg = ReleaseSL5|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseSL5|x86.ActiveCfg = ReleaseSL5|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseWP7|Any CPU.ActiveCfg = ReleaseWP7|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseWP7|Mixed Platforms.ActiveCfg = ReleaseWP7|Any CPU - {7269A578-326A-4C3E-9874-A2D2600095BC}.ReleaseWP7|x86.ActiveCfg = ReleaseWP7|Any CPU - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection -EndGlobal diff --git a/Ix/Interactive Extensions.vsmdi b/Ix/Interactive Extensions.vsmdi deleted file mode 100644 index 3031d67..0000000 --- a/Ix/Interactive Extensions.vsmdi +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/Ix/Interactive Extensions.vssscc b/Ix/Interactive Extensions.vssscc deleted file mode 100644 index 6cb031b..0000000 --- a/Ix/Interactive Extensions.vssscc +++ /dev/null @@ -1,10 +0,0 @@ -"" -{ -"FILE_VERSION" = "9237" -"ENLISTMENT_CHOICE" = "NEVER" -"PROJECT_FILE_RELATIVE_PATH" = "" -"NUMBER_OF_EXCLUDED_FILES" = "0" -"ORIGINAL_PROJECT_FILE_PATH" = "" -"NUMBER_OF_NESTED_PROJECTS" = "0" -"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT" -} diff --git a/Ix/Local.testsettings b/Ix/Local.testsettings deleted file mode 100644 index 9c078dd..0000000 --- a/Ix/Local.testsettings +++ /dev/null @@ -1,37 +0,0 @@ - - - These are default test settings for a local test run. - - - - - - - - - - -
-
-
-
- - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs deleted file mode 100644 index 8b0f766..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Aggregates.cs +++ /dev/null @@ -1,2019 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading.Tasks; -using System.Threading; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator, Func resultSelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - var tcs = new TaskCompletionSource(); - - var acc = seed; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - acc = accumulator(acc, e.Current); - f(ct); - } - catch (Exception exception) - { - tcs.TrySetException(exception); - } - } - else - { - var result = default(TResult); - try - { - result = resultSelector(acc); - } - catch (Exception exception) - { - tcs.TrySetException(exception); - return; - } - - tcs.TrySetResult(result); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return source.Aggregate(seed, accumulator, x => x, cancellationToken); - } - - public static Task Aggregate(this IAsyncEnumerable source, Func accumulator, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - var tcs = new TaskCompletionSource(); - - var first = true; - var acc = default(TSource); - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - if (first) - acc = e.Current; - else - acc = accumulator(acc, e.Current); - f(ct); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - } - - first = false; - } - else - { - if (first) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(acc); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Count(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0, (c, _) => c + 1, cancellationToken); - } - - public static Task Count(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).Aggregate(0, (c, _) => c + 1, cancellationToken); - } - - public static Task LongCount(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0L, (c, _) => c + 1, cancellationToken); - } - - public static Task LongCount(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).Aggregate(0L, (c, _) => c + 1, cancellationToken); - } - - public static Task All(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - if (!predicate(e.Current)) - tcs.TrySetResult(false); - else - f(ct); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - } - } - else - { - tcs.TrySetResult(true); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Any(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - if (predicate(e.Current)) - tcs.TrySetResult(true); - else - f(ct); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - } - } - else - { - tcs.TrySetResult(false); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Any(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var e = source.GetEnumerator(); - return e.MoveNext(cancellationToken); - } - - public static Task Contains(this IAsyncEnumerable source, TSource value, IEqualityComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Any(x => comparer.Equals(x, value), cancellationToken); - } - - public static Task Contains(this IAsyncEnumerable source, TSource value, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Contains(value, EqualityComparer.Default, cancellationToken); - } - - public static Task First(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - e.MoveNext(cancellationToken).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - tcs.TrySetResult(e.Current); - else - tcs.TrySetException(new InvalidOperationException()); - }); - }); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task First(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).First(cancellationToken); - } - - public static Task FirstOrDefault(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - e.MoveNext(cancellationToken).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - tcs.TrySetResult(e.Current); - else - tcs.TrySetResult(default(TSource)); - }); - }); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task FirstOrDefault(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).FirstOrDefault(cancellationToken); - } - - public static Task Last(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - var last = default(TSource); - var hasLast = false; - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - hasLast = true; - last = e.Current; - f(ct); - } - else - { - if (!hasLast) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(last); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Last(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).Last(cancellationToken); - } - - public static Task LastOrDefault(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - var last = default(TSource); - var hasLast = false; - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - hasLast = true; - last = e.Current; - f(ct); - } - else - { - if (!hasLast) - tcs.TrySetResult(default(TSource)); - else - tcs.TrySetResult(last); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task LastOrDefault(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).LastOrDefault(cancellationToken); - } - - public static Task Single(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - e.MoveNext(cancellationToken).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var result = e.Current; - e.MoveNext(cancellationToken).ContinueWith(t1 => - { - t1.Handle(tcs, res1 => - { - if (res1) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(result); - }); - }); - } - else - tcs.TrySetException(new InvalidOperationException()); - }); - }); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Single(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).Single(cancellationToken); - } - - public static Task SingleOrDefault(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - e.MoveNext(cancellationToken).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var result = e.Current; - e.MoveNext(cancellationToken).ContinueWith(t1 => - { - t1.Handle(tcs, res1 => - { - if (res1) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(result); - }); - }); - } - else - tcs.TrySetResult(default(TSource)); - }); - }); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task SingleOrDefault(this IAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return source.Where(predicate).SingleOrDefault(cancellationToken); - } - - public static Task ElementAt(this IAsyncEnumerable source, int index, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (index < 0) - throw new ArgumentOutOfRangeException("index"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - var next = default(Action); - next = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (index == 0) - { - tcs.TrySetResult(e.Current); - } - else - { - index--; - next(ct); - } - } - else - { - tcs.TrySetException(new ArgumentOutOfRangeException()); - } - }); - }); - - next(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task ElementAtOrDefault(this IAsyncEnumerable source, int index, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (index < 0) - throw new ArgumentOutOfRangeException("index"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - var next = default(Action); - next = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (index == 0) - { - tcs.TrySetResult(e.Current); - } - else - { - index--; - next(ct); - } - } - else - { - tcs.TrySetResult(default(TSource)); - } - }); - }); - - next(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task ToArray(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(new List(), (list, x) => { list.Add(x); return list; }, list => list.ToArray(), cancellationToken); - } - - public static Task> ToList(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(new List(), (list, x) => { list.Add(x); return list; }, cancellationToken); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Aggregate(new Dictionary(comparer), (d, x) => { d.Add(keySelector(x), elementSelector(x)); return d; }, cancellationToken); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - - return source.ToDictionary(keySelector, elementSelector, EqualityComparer.Default, cancellationToken); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.ToDictionary(keySelector, x => x, comparer, cancellationToken); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.ToDictionary(keySelector, x => x, EqualityComparer.Default, cancellationToken); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Aggregate(new Lookup(comparer), (lookup, x) => { lookup.Add(keySelector(x), elementSelector(x)); return lookup; }, lookup => (ILookup)lookup, cancellationToken); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - - return source.ToLookup(keySelector, elementSelector, EqualityComparer.Default, cancellationToken); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.ToLookup(keySelector, x => x, comparer, cancellationToken); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.ToLookup(keySelector, x => x, EqualityComparer.Default, cancellationToken); - } - - class Lookup : ILookup - { - private readonly Dictionary> map; - - public Lookup(IEqualityComparer comparer) - { - map = new Dictionary>(comparer); - } - - public void Add(TKey key, TElement element) - { - var g = default(EnumerableGrouping); - if (!map.TryGetValue(key, out g)) - { - g = new EnumerableGrouping(key); - map.Add(key, g); - } - - g.Add(element); - } - - public bool Contains(TKey key) - { - return map.ContainsKey(key); - } - - public int Count - { - get { return map.Keys.Count; } - } - - public IEnumerable this[TKey key] - { - get { return map[key]; } - } - - public IEnumerator> GetEnumerator() - { - return map.Values.Cast>().GetEnumerator(); - } - - System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { - return GetEnumerator(); - } - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0.0; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - count++; - sum += e.Current; - f(ct); - } - else - { - if (count == 0) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0.0; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (e.Current.HasValue) - { - count++; - sum += e.Current.Value; - } - f(ct); - } - else - { - if (count == 0) - tcs.TrySetResult(null); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0.0; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - count++; - sum += e.Current; - f(ct); - } - else - { - if (count == 0) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0.0; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (e.Current.HasValue) - { - count++; - sum += e.Current.Value; - } - f(ct); - } - else - { - if (count == 0) - tcs.TrySetResult(null); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0.0; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - count++; - sum += e.Current; - f(ct); - } - else - { - if (count == 0) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0.0; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (e.Current.HasValue) - { - count++; - sum += e.Current.Value; - } - f(ct); - } - else - { - if (count == 0) - tcs.TrySetResult(null); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0f; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - count++; - sum += e.Current; - f(ct); - } - else - { - if (count == 0) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0f; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (e.Current.HasValue) - { - count++; - sum += e.Current.Value; - } - f(ct); - } - else - { - if (count == 0) - tcs.TrySetResult(null); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0m; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - count++; - sum += e.Current; - f(ct); - } - else - { - if (count == 0) - tcs.TrySetException(new InvalidOperationException()); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var tcs = new TaskCompletionSource(); - - var count = 0L; - var sum = 0m; - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (e.Current.HasValue) - { - count++; - sum += e.Current.Value; - } - f(ct); - } - else - { - if (count == 0) - tcs.TrySetResult(null); - else - tcs.TrySetResult(sum / count); - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Average(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Average(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Max, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Max, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Max, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Max, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Max, cancellationToken); - } - - static T? NullableMax(T? x, T? y) - where T : struct, IComparable - { - if (!x.HasValue) - return y; - if (!y.HasValue) - return x; - if (x.Value.CompareTo(y.Value) >= 0) - return x; - return y; - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(int?), NullableMax, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(long?), NullableMax, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(double?), NullableMax, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(float?), NullableMax, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(decimal?), NullableMax, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var comparer = Comparer.Default; - return source.Aggregate((x, y) => comparer.Compare(x, y) >= 0 ? x : y, cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Max(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Min, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Min, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Min, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Min, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(Math.Min, cancellationToken); - } - - static T? NullableMin(T? x, T? y) - where T : struct, IComparable - { - if (!x.HasValue) - return y; - if (!y.HasValue) - return x; - if (x.Value.CompareTo(y.Value) <= 0) - return x; - return y; - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(int?), NullableMin, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(long?), NullableMin, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(double?), NullableMin, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(float?), NullableMin, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(default(decimal?), NullableMin, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - var comparer = Comparer.Default; - return source.Aggregate((x, y) => comparer.Compare(x, y) <= 0 ? x : y, cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Min(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Min(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0, (x, y) => x + y, cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0L, (x, y) => x + y, cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0.0, (x, y) => x + y, cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0f, (x, y) => x + y, cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate(0m, (x, y) => x + y, cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate((int?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate((long?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate((double?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate((float?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Aggregate((decimal?)0, (x, y) => x + y.GetValueOrDefault(), cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Select(selector).Sum(cancellationToken); - } - - public static Task IsEmpty(this IAsyncEnumerable source, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Any(cancellationToken).ContinueWith(t => !t.Result); - } - - public static Task Min(this IAsyncEnumerable source, IComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return MinBy(source, x => x, comparer, cancellationToken).ContinueWith(t => t.Result.First()); - } - - public static Task> MinBy(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return MinBy(source, keySelector, Comparer.Default, cancellationToken); - } - - public static Task> MinBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ExtremaBy(source, keySelector, (key, minValue) => -comparer.Compare(key, minValue), cancellationToken); - } - - public static Task Max(this IAsyncEnumerable source, IComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return MaxBy(source, x => x, comparer, cancellationToken).ContinueWith(t => t.Result.First()); - } - - public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return MaxBy(source, keySelector, Comparer.Default, cancellationToken); - } - - public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ExtremaBy(source, keySelector, (key, minValue) => comparer.Compare(key, minValue), cancellationToken); - } - - private static Task> ExtremaBy(IAsyncEnumerable source, Func keySelector, Func compare, CancellationToken cancellationToken) - { - var tcs = new TaskCompletionSource>(); - - var result = new List(); - - var hasFirst = false; - var current = default(TSource); - var resKey = default(TKey); - - var e = source.GetEnumerator(); - - var f = default(Action); - f = ct => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (!hasFirst) - { - if (!res) - { - tcs.TrySetException(new InvalidOperationException("Source sequence doesn't contain any elements.")); - return; - } - - current = e.Current; - - try - { - resKey = keySelector(current); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - result.Add(current); - - hasFirst = true; - f(ct); - } - else - { - if (res) - { - var key = default(TKey); - var cmp = default(int); - - try - { - current = e.Current; - key = keySelector(current); - cmp = compare(key, resKey); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (cmp == 0) - { - result.Add(current); - } - else if (cmp > 0) - { - result = new List { current }; - resKey = key; - } - - f(ct); - } - else - { - tcs.TrySetResult(result); - } - } - }); - }); - - f(cancellationToken); - - return tcs.Task.Finally(e.Dispose); - } - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs deleted file mode 100644 index 2c66eec..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Conversions.cs +++ /dev/null @@ -1,262 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading.Tasks; -using System.Threading; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - public static IAsyncEnumerable ToAsyncEnumerable(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Create(() => - { - var e = source.GetEnumerator(); - - return Create( - ct => Task.Factory.StartNew(() => - { - var res = default(bool); - try - { - res = e.MoveNext(); - } - finally - { - if (!res) - e.Dispose(); - } - return res; - }, ct), - () => e.Current, - () => e.Dispose() - ); - }); - } - - public static IEnumerable ToEnumerable(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return ToEnumerable_(source); - } - - private static IEnumerable ToEnumerable_(IAsyncEnumerable source) - { - using (var e = source.GetEnumerator()) - { - while (true) - { - var t = e.MoveNext(CancellationToken.None); - t.Wait(); - if (!t.Result) - break; - var c = e.Current; - yield return c; - } - } - } - -#if !NO_RXINTERFACES - public static IAsyncEnumerable ToAsyncEnumerable(this IObservable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Create(() => - { - var observer = new ToAsyncEnumerableObserver(); - observer.Queue = new Queue>(); - - var subscription = source.Subscribe(observer); - - return Create( - (ct, tcs) => - { - lock (observer.Queue) - { - if (observer.Queue.Count > 0) - { - var n = observer.Queue.Dequeue(); - n.Switch( - x => - { - observer.Current = x; - tcs.TrySetResult(true); - }, - ex => - { - tcs.TrySetException(ex); - }, - _ => - { - tcs.TrySetResult(false); - } - ); - } - else - observer.TaskCompletionSource = tcs; - } - - return tcs.Task; - }, - () => observer.Current, - () => - { - subscription.Dispose(); - // Should we cancel in-flight operations somehow? - }); - }); - } - - class ToAsyncEnumerableObserver : IObserver - { - public Queue> Queue { get; set; } - public T Current { get; set; } - public TaskCompletionSource TaskCompletionSource { get; set; } - - public void OnCompleted() - { - lock (Queue) - { - if (TaskCompletionSource == null) - Queue.Enqueue(new Either.Choice3(true)); - else - { - TaskCompletionSource.SetResult(false); - TaskCompletionSource = null; - } - } - } - - public void OnError(Exception error) - { - lock (Queue) - { - if (TaskCompletionSource == null) - Queue.Enqueue(new Either.Choice2(error)); - else - { - TaskCompletionSource.SetException(error); - TaskCompletionSource = null; - } - } - } - - public void OnNext(T value) - { - lock (Queue) - { - if (TaskCompletionSource == null) - Queue.Enqueue(new Either.Choice1(value)); - else - { - Current = value; - TaskCompletionSource.SetResult(true); - TaskCompletionSource = null; - } - } - } - } - - abstract class Either - { - public abstract void Switch(Action choice1, Action choice2, Action choice3); - - public class Choice1 : Either - { - public Choice1(T value) { Value = value; } - public T Value { get; private set; } - - public override void Switch(Action choice1, Action choice2, Action choice3) - { - choice1(Value); - } - } - - public class Choice2 : Either - { - public Choice2(U value) { Value = value; } - public U Value { get; private set; } - - public override void Switch(Action choice1, Action choice2, Action choice3) - { - choice2(Value); - } - } - - public class Choice3 : Either - { - public Choice3(V value) { Value = value; } - public V Value { get; private set; } - - public override void Switch(Action choice1, Action choice2, Action choice3) - { - choice3(Value); - } - } - } - - public static IObservable ToObservable(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return new ToObservableObservable(source); - } - - class ToObservableObservable : IObservable - { - private readonly IAsyncEnumerable source; - - public ToObservableObservable(IAsyncEnumerable source) - { - this.source = source; - } - - public IDisposable Subscribe(IObserver observer) - { - var ctd = new CancellationTokenDisposable(); - var e = source.GetEnumerator(); - - var f = default(Action); - f = () => e.MoveNext(ctd.Token).ContinueWith(t => - { - if (t.IsFaulted) - { - observer.OnError(t.Exception); - e.Dispose(); - } - else if (t.IsCanceled) - { - e.Dispose(); - } - else if (t.IsCompleted) - { - if (t.Result) - { - observer.OnNext(e.Current); - f(); - } - else - { - observer.OnCompleted(); - e.Dispose(); - } - } - }, ctd.Token); - - f(); - - return new CompositeDisposable(ctd, e); - } - } -#endif - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs deleted file mode 100644 index f930293..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Creation.cs +++ /dev/null @@ -1,283 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; -using System.Threading.Tasks; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - static IAsyncEnumerable Create(Func> getEnumerator) - { - return new AnonymousAsyncEnumerable(getEnumerator); - } - - class AnonymousAsyncEnumerable : IAsyncEnumerable - { - Func> getEnumerator; - - public AnonymousAsyncEnumerable(Func> getEnumerator) - { - this.getEnumerator = getEnumerator; - } - - public IAsyncEnumerator GetEnumerator() - { - return getEnumerator(); - } - } - - static IAsyncEnumerator Create(Func> moveNext, Func current, Action dispose) - { - return new AnonymousAsyncEnumerator(moveNext, current, dispose); - } - - static IAsyncEnumerator Create(Func, Task> moveNext, Func current, Action dispose) - { - var self = default(IAsyncEnumerator); - self = new AnonymousAsyncEnumerator( - ct => - { - var tcs = new TaskCompletionSource(); - - var stop = new Action(() => - { - self.Dispose(); - tcs.TrySetCanceled(); - }); - - var ctr = ct.Register(stop); - - var res = moveNext(ct, tcs).Finally(ctr.Dispose); - return res; - }, - current, - dispose - ); - return self; - } - - class AnonymousAsyncEnumerator : IAsyncEnumerator - { - private readonly Func> _moveNext; - private readonly Func _current; - private readonly Action _dispose; - private bool _disposed; - - public AnonymousAsyncEnumerator(Func> moveNext, Func current, Action dispose) - { - _moveNext = moveNext; - _current = current; - _dispose = dispose; - } - - public Task MoveNext(CancellationToken cancellationToken) - { - if (_disposed) - return TaskExt.Return(false, CancellationToken.None); - - return _moveNext(cancellationToken); - } - - public T Current - { - get - { - return _current(); - } - } - - public void Dispose() - { - if (!_disposed) - { - _disposed = true; - _dispose(); - } - } - } - - public static IAsyncEnumerable Return(TValue value) - { - return new[] { value }.ToAsyncEnumerable(); - } - - public static IAsyncEnumerable Throw(Exception exception) - { - if (exception == null) - throw new ArgumentNullException("exception"); - - return Create(() => Create( - ct => TaskExt.Throw(exception, ct), - () => { throw new InvalidOperationException(); }, - () => { }) - ); - } - - public static IAsyncEnumerable Never() - { - return Create(() => Create( - (ct, tcs) => tcs.Task, - () => { throw new InvalidOperationException(); }, - () => { }) - ); - } - - public static IAsyncEnumerable Empty() - { - return Create(() => Create( - ct => TaskExt.Return(false, ct), - () => { throw new InvalidOperationException(); }, - () => { }) - ); - } - - public static IAsyncEnumerable Range(int start, int count) - { - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Enumerable.Range(start, count).ToAsyncEnumerable(); - } - - public static IAsyncEnumerable Repeat(TResult element, int count) - { - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Enumerable.Repeat(element, count).ToAsyncEnumerable(); - } - - public static IAsyncEnumerable Repeat(TResult element) - { - return Create(() => - { - return Create( - ct => TaskExt.Return(true, ct), - () => element, - () => { } - ); - }); - } - - public static IAsyncEnumerable Defer(Func> factory) - { - if (factory == null) - throw new ArgumentNullException("factory"); - - return Create(() => factory().GetEnumerator()); - } - - public static IAsyncEnumerable Generate(TState initialState, Func condition, Func iterate, Func resultSelector) - { - if (condition == null) - throw new ArgumentNullException("condition"); - if (iterate == null) - throw new ArgumentNullException("iterate"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return Create(() => - { - var i = initialState; - var started = false; - var current = default(TResult); - - return Create( - ct => - { - var b = false; - try - { - if (started) - i = iterate(i); - - b = condition(i); - - if (b) - current = resultSelector(i); - } - catch (Exception ex) - { - return TaskExt.Throw(ex, ct); - } - - if (!b) - return TaskExt.Return(false, ct); - - if (!started) - started = true; - - return TaskExt.Return(true, ct); - }, - () => current, - () => { } - ); - }); - } - - public static IAsyncEnumerable Using(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable - { - if (resourceFactory == null) - throw new ArgumentNullException("resourceFactory"); - if (enumerableFactory == null) - throw new ArgumentNullException("enumerableFactory"); - - return Create(() => - { - var resource = resourceFactory(); - var e = default(IAsyncEnumerator); - - try - { - e = enumerableFactory(resource).GetEnumerator(); - } - catch (Exception) - { - resource.Dispose(); - throw; - } - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, resource, e); - - var current = default(TSource); - - return Create( - (ct, tcs) => - { - e.MoveNext(cts.Token).ContinueWith(t => - { - t.Handle(tcs, - res => - { - if (res) - { - current = e.Current; - tcs.TrySetResult(true); - } - else - { - d.Dispose(); - tcs.TrySetResult(false); - } - }, - ex => - { - d.Dispose(); - tcs.TrySetException(ex); - } - ); - }); - - return tcs.Task; - }, - () => current, - d.Dispose - ); - }); - } - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs deleted file mode 100644 index db33c61..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Exceptions.cs +++ /dev/null @@ -1,381 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; -using System.Threading.Tasks; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - public static IAsyncEnumerable Catch(this IAsyncEnumerable source, Func> handler) - where TException : Exception - { - if (source == null) - throw new ArgumentNullException("source"); - if (handler == null) - throw new ArgumentNullException("handler"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var a = new AssignableDisposable { Disposable = e }; - var d = new CompositeDisposable(cts, a); - var done = false; - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (!done) - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, - res => - { - tcs.TrySetResult(res); - }, - ex => - { - var err = default(IAsyncEnumerator); - - try - { - ex.Flatten().Handle(ex_ => - { - var exx = ex_ as TException; - if (exx != null) - { - err = handler(exx).GetEnumerator(); - return true; - } - - return false; - }); - } - catch (Exception ex2) - { - tcs.TrySetException(ex2); - return; - } - - if (err != null) - { - e = err; - a.Disposable = e; - - done = true; - f(tcs, ct); - } - } - ); - }); - } - else - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - tcs.TrySetResult(res); - }); - }); - } - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(a); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Catch(this IEnumerable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Catch_(); - } - - public static IAsyncEnumerable Catch(params IAsyncEnumerable[] sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Catch_(); - } - - public static IAsyncEnumerable Catch(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return new[] { first, second }.Catch_(); - } - - private static IAsyncEnumerable Catch_(this IEnumerable> sources) - { - return Create(() => - { - var se = sources.GetEnumerator(); - var e = default(IAsyncEnumerator); - - var cts = new CancellationTokenDisposable(); - var a = new AssignableDisposable(); - var d = new CompositeDisposable(cts, se, a); - - var error = default(Exception); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (e == null) - { - var b = false; - try - { - b = se.MoveNext(); - if (b) - e = se.Current.GetEnumerator(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (!b) - { - if (error != null) - { - tcs.TrySetException(error); - return; - } - - tcs.TrySetResult(false); - return; - } - - error = null; - - a.Disposable = e; - } - - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, - res => - { - tcs.TrySetResult(res); - }, - ex => - { - e.Dispose(); - e = null; - - error = ex; - f(tcs, ct); - } - ); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(a); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Finally(this IAsyncEnumerable source, Action finallyAction) - { - if (source == null) - throw new ArgumentNullException("source"); - if (finallyAction == null) - throw new ArgumentNullException("finallyAction"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var r = new Disposable(finallyAction); - var d = new CompositeDisposable(cts, e, r); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - tcs.TrySetResult(res); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumeratorSync(r); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable OnErrorResumeNext(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return OnErrorResumeNext_(new[] { first, second }); - } - - public static IAsyncEnumerable OnErrorResumeNext(params IAsyncEnumerable[] sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return OnErrorResumeNext_(sources); - } - - public static IAsyncEnumerable OnErrorResumeNext(this IEnumerable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return OnErrorResumeNext_(sources); - } - - private static IAsyncEnumerable OnErrorResumeNext_(IEnumerable> sources) - { - return Create(() => - { - var se = sources.GetEnumerator(); - var e = default(IAsyncEnumerator); - - var cts = new CancellationTokenDisposable(); - var a = new AssignableDisposable(); - var d = new CompositeDisposable(cts, se, a); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (e == null) - { - var b = false; - try - { - b = se.MoveNext(); - if (b) - e = se.Current.GetEnumerator(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (!b) - { - tcs.TrySetResult(false); - return; - } - - a.Disposable = e; - } - - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, - res => - { - if (res) - { - tcs.TrySetResult(true); - } - else - { - e.Dispose(); - e = null; - - f(tcs, ct); - } - }, - ex => - { - e.Dispose(); - e = null; - - f(tcs, ct); - } - ); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(a); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Retry(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return new[] { source }.Repeat().Catch(); - } - - public static IAsyncEnumerable Retry(this IAsyncEnumerable source, int retryCount) - { - if (source == null) - throw new ArgumentNullException("source"); - if (retryCount < 0) - throw new ArgumentOutOfRangeException("retryCount"); - - return new[] { source }.Repeat(retryCount).Catch(); - } - - private static IEnumerable Repeat(this IEnumerable source) - { - while (true) - foreach (var item in source) - yield return item; - } - - private static IEnumerable Repeat(this IEnumerable source, int count) - { - for (var i = 0; i < count; i++) - foreach (var item in source) - yield return item; - } - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs deleted file mode 100644 index 23c6c8d..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Generated.cs +++ /dev/null @@ -1,1250 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System.Collections.Generic; -using System.Threading; -using System.Threading.Tasks; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Sum(source, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static Task Sum(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Sum(source, selector, CancellationToken.None); - } - - public static void ForEach(this IAsyncEnumerable source, Action action) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - source.ForEachAsync(action).Wait(); - } - - public static Task ForEachAsync(this IAsyncEnumerable source, Action action) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - return ForEachAsync(source, action, CancellationToken.None); - } - - public static void ForEach(this IAsyncEnumerable source, Action action) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - source.ForEachAsync(action).Wait(); - } - - public static Task ForEachAsync(this IAsyncEnumerable source, Action action) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - return ForEachAsync(source, action, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Average(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Max(source, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Max(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Min(source, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Min(source, selector, CancellationToken.None); - } - - public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return SequenceEqual(first, second, comparer, CancellationToken.None); - } - - public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return SequenceEqual(first, second, CancellationToken.None); - } - - public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator, Func resultSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return Aggregate(source, seed, accumulator, resultSelector, CancellationToken.None); - } - - public static Task Aggregate(this IAsyncEnumerable source, TAccumulate seed, Func accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return Aggregate(source, seed, accumulator, CancellationToken.None); - } - - public static Task Aggregate(this IAsyncEnumerable source, Func accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return Aggregate(source, accumulator, CancellationToken.None); - } - - public static Task Count(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Count(source, CancellationToken.None); - } - - public static Task Count(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Count(source, predicate, CancellationToken.None); - } - - public static Task LongCount(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return LongCount(source, CancellationToken.None); - } - - public static Task LongCount(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return LongCount(source, predicate, CancellationToken.None); - } - - public static Task All(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return All(source, predicate, CancellationToken.None); - } - - public static Task Any(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Any(source, predicate, CancellationToken.None); - } - - public static Task Any(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Any(source, CancellationToken.None); - } - - public static Task Contains(this IAsyncEnumerable source, TSource value, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Contains(source, value, comparer, CancellationToken.None); - } - - public static Task Contains(this IAsyncEnumerable source, TSource value) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Contains(source, value, CancellationToken.None); - } - - public static Task First(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return First(source, CancellationToken.None); - } - - public static Task First(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return First(source, predicate, CancellationToken.None); - } - - public static Task FirstOrDefault(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return FirstOrDefault(source, CancellationToken.None); - } - - public static Task FirstOrDefault(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return FirstOrDefault(source, predicate, CancellationToken.None); - } - - public static Task Last(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Last(source, CancellationToken.None); - } - - public static Task Last(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Last(source, predicate, CancellationToken.None); - } - - public static Task LastOrDefault(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return LastOrDefault(source, CancellationToken.None); - } - - public static Task LastOrDefault(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return LastOrDefault(source, predicate, CancellationToken.None); - } - - public static Task Single(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Single(source, CancellationToken.None); - } - - public static Task Single(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Single(source, predicate, CancellationToken.None); - } - - public static Task SingleOrDefault(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return SingleOrDefault(source, CancellationToken.None); - } - - public static Task SingleOrDefault(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return SingleOrDefault(source, predicate, CancellationToken.None); - } - - public static Task ElementAt(this IAsyncEnumerable source, int index) - { - if (source == null) - throw new ArgumentNullException("source"); - - return ElementAt(source, index, CancellationToken.None); - } - - public static Task ElementAtOrDefault(this IAsyncEnumerable source, int index) - { - if (source == null) - throw new ArgumentNullException("source"); - - return ElementAtOrDefault(source, index, CancellationToken.None); - } - - public static Task ToArray(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return ToArray(source, CancellationToken.None); - } - - public static Task> ToList(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return ToList(source, CancellationToken.None); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ToDictionary(source, keySelector, elementSelector, comparer, CancellationToken.None); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, Func elementSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - - return ToDictionary(source, keySelector, elementSelector, CancellationToken.None); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ToDictionary(source, keySelector, comparer, CancellationToken.None); - } - - public static Task> ToDictionary(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return ToDictionary(source, keySelector, CancellationToken.None); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ToLookup(source, keySelector, elementSelector, comparer, CancellationToken.None); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, Func elementSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - - return ToLookup(source, keySelector, elementSelector, CancellationToken.None); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ToLookup(source, keySelector, comparer, CancellationToken.None); - } - - public static Task> ToLookup(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return ToLookup(source, keySelector, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task Average(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Average(source, CancellationToken.None); - } - - public static Task IsEmpty(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.IsEmpty(CancellationToken.None); - } - - public static Task Min(this IAsyncEnumerable source, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Min(comparer, CancellationToken.None); - } - - public static Task> MinBy(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.MinBy(keySelector, CancellationToken.None); - } - - public static Task> MinBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.MinBy(keySelector, comparer, CancellationToken.None); - } - - public static Task Max(this IAsyncEnumerable source, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Max(comparer, CancellationToken.None); - } - - public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.MaxBy(keySelector, CancellationToken.None); - } - - public static Task> MaxBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.MaxBy(keySelector, comparer, CancellationToken.None); - } - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs deleted file mode 100644 index a8069b2..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Multiple.cs +++ /dev/null @@ -1,755 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading.Tasks; -using System.Threading; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - public static IAsyncEnumerable Concat(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return Create(() => - { - var switched = false; - var e = first.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var a = new AssignableDisposable { Disposable = e }; - var d = new CompositeDisposable(cts, a); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - tcs.TrySetResult(true); - } - else - { - if (switched) - { - tcs.TrySetResult(false); - } - else - { - switched = true; - - e = second.GetEnumerator(); - a.Disposable = e; - - f(tcs, ct); - } - } - }); - }); - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(a); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Zip(this IAsyncEnumerable first, IAsyncEnumerable second, Func selector) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => - { - var e1 = first.GetEnumerator(); - var e2 = second.GetEnumerator(); - var current = default(TResult); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e1, e2); - - return Create( - (ct, tcs) => - { - e1.MoveNext(cts.Token).Zip(e2.MoveNext(cts.Token), (f, s) => - { - var result = f && s; - if (result) - current = selector(e1.Current, e2.Current); - return result; - }).ContinueWith(t => - { - t.Handle(tcs, x => tcs.TrySetResult(x)); - }); - - return tcs.Task.UsingEnumerator(e1).UsingEnumerator(e2); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Except(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Create(() => - { - var e = first.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var mapTask = default(Task>); - var getMapTask = new Func>>(ct => - { - if (mapTask == null) - mapTask = second.ToDictionary(x => x, comparer, ct); - return mapTask; - }); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (!mapTask.Result.ContainsKey(e.Current)) - tcs.TrySetResult(true); - else - f(tcs, ct); - } - else - tcs.TrySetResult(false); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Except(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return first.Except(second, EqualityComparer.Default); - } - - public static IAsyncEnumerable Intersect(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Create(() => - { - var e = first.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var mapTask = default(Task>); - var getMapTask = new Func>>(ct => - { - if (mapTask == null) - mapTask = second.ToDictionary(x => x, comparer, ct); - return mapTask; - }); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).Zip(getMapTask(ct), (b, _) => b).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - if (mapTask.Result.ContainsKey(e.Current)) - tcs.TrySetResult(true); - else - f(tcs, ct); - } - else - tcs.TrySetResult(false); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Intersect(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return first.Intersect(second, EqualityComparer.Default); - } - - public static IAsyncEnumerable Union(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return first.Concat(second).Distinct(comparer); - } - - public static IAsyncEnumerable Union(this IAsyncEnumerable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return first.Union(second, EqualityComparer.Default); - } - - public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second, IEqualityComparer comparer, CancellationToken cancellationToken) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - var tcs = new TaskCompletionSource(); - - var e1 = first.GetEnumerator(); - var e2 = second.GetEnumerator(); - - var run = default(Action); - run = ct => - { - e1.MoveNext(ct).Zip(e2.MoveNext(ct), (f, s) => - { - if (f ^ s) - { - tcs.TrySetResult(false); - return false; - } - - if (f && s) - { - var eq = default(bool); - try - { - eq = comparer.Equals(e1.Current, e2.Current); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return false; - } - - if (!eq) - { - tcs.TrySetResult(false); - return false; - } - else - return true; - } - else - { - tcs.TrySetResult(true); - return false; - } - }).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - run(ct); - }); - }); - }; - - run(cancellationToken); - - return tcs.Task.Finally(() => - { - e1.Dispose(); - e2.Dispose(); - }); - } - - public static Task SequenceEqual(this IAsyncEnumerable first, IAsyncEnumerable second, CancellationToken cancellationToken) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return first.SequenceEqual(second, EqualityComparer.Default, cancellationToken); - } - - public static IAsyncEnumerable GroupJoin(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer comparer) - { - if (outer == null) - throw new ArgumentNullException("outer"); - if (inner == null) - throw new ArgumentNullException("inner"); - if (outerKeySelector == null) - throw new ArgumentNullException("outerKeySelector"); - if (innerKeySelector == null) - throw new ArgumentNullException("innerKeySelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Create(() => - { - var innerMap = default(Task>); - var getInnerMap = new Func>>(ct => - { - if (innerMap == null) - innerMap = inner.ToLookup(innerKeySelector, comparer, ct); - - return innerMap; - }); - - var outerE = outer.GetEnumerator(); - var current = default(TResult); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, outerE); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - getInnerMap(ct).ContinueWith(ti => - { - ti.Handle(tcs, map => - { - outerE.MoveNext(ct).ContinueWith(to => - { - to.Handle(tcs, res => - { - if (res) - { - var element = outerE.Current; - var key = default(TKey); - - try - { - key = outerKeySelector(element); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - var innerE = default(IAsyncEnumerable); - if (!map.Contains(key)) - innerE = AsyncEnumerable.Empty(); - else - innerE = map[key].ToAsyncEnumerable(); - - try - { - current = resultSelector(element, innerE); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - tcs.TrySetResult(true); - } - else - { - tcs.TrySetResult(false); - } - }); - }); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(outerE); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable GroupJoin(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector) - { - if (outer == null) - throw new ArgumentNullException("outer"); - if (inner == null) - throw new ArgumentNullException("inner"); - if (outerKeySelector == null) - throw new ArgumentNullException("outerKeySelector"); - if (innerKeySelector == null) - throw new ArgumentNullException("innerKeySelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return outer.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); - } - - public static IAsyncEnumerable Join(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer) - { - if (outer == null) - throw new ArgumentNullException("outer"); - if (inner == null) - throw new ArgumentNullException("inner"); - if (outerKeySelector == null) - throw new ArgumentNullException("outerKeySelector"); - if (innerKeySelector == null) - throw new ArgumentNullException("innerKeySelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Create(() => - { - var oe = outer.GetEnumerator(); - var ie = inner.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, oe, ie); - - var current = default(TResult); - var useOuter = true; - var outerMap = new Dictionary>(comparer); - var innerMap = new Dictionary>(comparer); - var q = new Queue(); - - var gate = new object(); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (q.Count > 0) - { - current = q.Dequeue(); - tcs.TrySetResult(true); - return; - } - - var b = useOuter; - if (ie == null && oe == null) - { - tcs.TrySetResult(false); - return; - } - else if (ie == null) - b = true; - else if (oe == null) - b = false; - useOuter = !useOuter; - - var enqueue = new Func((o, i) => - { - var result = default(TResult); - try - { - result = resultSelector(o, i); - } - catch (Exception exception) - { - tcs.TrySetException(exception); - return false; - } - - q.Enqueue(result); - return true; - }); - - if (b) - oe.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var element = oe.Current; - var key = default(TKey); - - try - { - key = outerKeySelector(element); - } - catch (Exception exception) - { - tcs.TrySetException(exception); - return; - } - - var outerList = default(List); - if (!outerMap.TryGetValue(key, out outerList)) - { - outerList = new List(); - outerMap.Add(key, outerList); - } - - outerList.Add(element); - - var innerList = default(List); - if (!innerMap.TryGetValue(key, out innerList)) - { - innerList = new List(); - innerMap.Add(key, innerList); - } - - foreach (var v in innerList) - { - if (!enqueue(element, v)) - return; - } - - f(tcs, ct); - } - else - { - oe.Dispose(); - oe = null; - f(tcs, ct); - } - }); - }); - else - ie.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var element = ie.Current; - var key = default(TKey); - - try - { - key = innerKeySelector(element); - } - catch (Exception exception) - { - tcs.TrySetException(exception); - return; - } - - var innerList = default(List); - if (!innerMap.TryGetValue(key, out innerList)) - { - innerList = new List(); - innerMap.Add(key, innerList); - } - - innerList.Add(element); - - var outerList = default(List); - if (!outerMap.TryGetValue(key, out outerList)) - { - outerList = new List(); - outerMap.Add(key, outerList); - } - - foreach (var v in outerList) - { - if (!enqueue(v, element)) - return; - } - - f(tcs, ct); - } - else - { - ie.Dispose(); - ie = null; - f(tcs, ct); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(oe).UsingEnumerator(ie); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Join(this IAsyncEnumerable outer, IAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector) - { - if (outer == null) - throw new ArgumentNullException("outer"); - if (inner == null) - throw new ArgumentNullException("inner"); - if (outerKeySelector == null) - throw new ArgumentNullException("outerKeySelector"); - if (innerKeySelector == null) - throw new ArgumentNullException("innerKeySelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return outer.Join(inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); - } - - public static IAsyncEnumerable Concat(this IEnumerable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Concat_(); - } - - public static IAsyncEnumerable Concat(params IAsyncEnumerable[] sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Concat_(); - } - - private static IAsyncEnumerable Concat_(this IEnumerable> sources) - { - return Create(() => - { - var se = sources.GetEnumerator(); - var e = default(IAsyncEnumerator); - - var cts = new CancellationTokenDisposable(); - var a = new AssignableDisposable(); - var d = new CompositeDisposable(cts, se, a); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (e == null) - { - var b = false; - try - { - b = se.MoveNext(); - if (b) - e = se.Current.GetEnumerator(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (!b) - { - tcs.TrySetResult(false); - return; - } - - a.Disposable = e; - } - - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - tcs.TrySetResult(true); - } - else - { - e.Dispose(); - e = null; - - f(tcs, ct); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(a); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, IAsyncEnumerable other) - { - if (source == null) - throw new ArgumentNullException("source"); - if (other == null) - throw new ArgumentNullException("other"); - - return source.SelectMany(_ => other); - } - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerable.Single.cs b/Ix/System.Interactive.Async/AsyncEnumerable.Single.cs deleted file mode 100644 index bab56a2..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerable.Single.cs +++ /dev/null @@ -1,2466 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; -using System.Threading.Tasks; - -namespace System.Linq -{ - public static partial class AsyncEnumerable - { - public static IAsyncEnumerable Select(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => - { - var e = source.GetEnumerator(); - var current = default(TResult); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - return Create( - (ct, tcs) => - { - e.MoveNext(cts.Token).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - current = selector(e.Current); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - tcs.TrySetResult(true); - } - else - { - tcs.TrySetResult(false); - } - }); - }); - - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Select(this IAsyncEnumerable source, Func selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => - { - var e = source.GetEnumerator(); - var current = default(TResult); - var index = 0; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - return Create( - (ct, tcs) => - { - e.MoveNext(cts.Token).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - current = selector(e.Current, index++); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - tcs.TrySetResult(true); - } - else - { - tcs.TrySetResult(false); - } - }); - }); - - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable AsAsyncEnumerable(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Select(x => x); - } - - public static IAsyncEnumerable Where(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var b = false; - try - { - b = predicate(e.Current); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (b) - tcs.TrySetResult(true); - else - f(tcs, ct); - } - else - tcs.TrySetResult(false); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Where(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Create(() => - { - var e = source.GetEnumerator(); - var index = 0; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var b = false; - try - { - b = predicate(e.Current, index++); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (b) - tcs.TrySetResult(true); - else - f(tcs, ct); - } - else - tcs.TrySetResult(false); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => - { - var e = source.GetEnumerator(); - var ie = default(IAsyncEnumerator); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var outer = default(Action, CancellationToken>); - var inner = default(Action, CancellationToken>); - - inner = (tcs, ct) => - { - ie.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - tcs.TrySetResult(true); - } - else - { - ie = null; - outer(tcs, ct); - } - }); - }); - }; - - outer = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - ie = selector(e.Current).GetEnumerator(); - inner(tcs, ct); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - } - } - else - tcs.TrySetResult(false); - }); - }); - }; - - return Create( - (ct, tcs) => - { - if (ie == null) - outer(tcs, cts.Token); - else - inner(tcs, cts.Token); - - return tcs.Task.UsingEnumerator(e); - }, - () => ie.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => - { - var e = source.GetEnumerator(); - var ie = default(IAsyncEnumerator); - var index = 0; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var outer = default(Action, CancellationToken>); - var inner = default(Action, CancellationToken>); - - inner = (tcs, ct) => - { - ie.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - tcs.TrySetResult(true); - } - else - { - ie = null; - outer(tcs, ct); - } - }); - }); - }; - - outer = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - ie = selector(e.Current, index++).GetEnumerator(); - inner(tcs, ct); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - } - } - else - tcs.TrySetResult(false); - }); - }); - }; - - return Create( - (ct, tcs) => - { - if (ie == null) - outer(tcs, cts.Token); - else - inner(tcs, cts.Token); - - return tcs.Task.UsingEnumerator(e); - }, - () => ie.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector, Func resultSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return source.SelectMany(x => selector(x).Select(y => resultSelector(x, y))); - } - - public static IAsyncEnumerable SelectMany(this IAsyncEnumerable source, Func> selector, Func resultSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return source.SelectMany((x, i) => selector(x, i).Select(y => resultSelector(x, y))); - } - - public static IAsyncEnumerable OfType(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Where(x => x is TType).Cast(); - } - - public static IAsyncEnumerable Cast(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Select(x => (TResult)x); - } - - public static IAsyncEnumerable Take(this IAsyncEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Create(() => - { - var e = source.GetEnumerator(); - var n = count; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - return Create( - (ct, tcs) => - { - if (n == 0) - return TaskExt.Return(false, cts.Token); - - e.MoveNext(cts.Token).ContinueWith(t => - { - t.Handle(tcs, res => - { - --n; - tcs.TrySetResult(res); - }); - }); - - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable TakeWhile(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - return Create( - (ct, tcs) => - { - e.MoveNext(cts.Token).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var b = false; - - try - { - b = predicate(e.Current); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (b) - { - tcs.TrySetResult(true); - return; - } - } - tcs.TrySetResult(false); - }); - }); - - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable TakeWhile(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Create(() => - { - var e = source.GetEnumerator(); - var index = 0; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - return Create( - (ct, tcs) => - { - e.MoveNext(cts.Token).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var b = false; - - try - { - b = predicate(e.Current, index++); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (b) - { - tcs.TrySetResult(true); - return; - } - } - tcs.TrySetResult(false); - }); - }); - - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Skip(this IAsyncEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Create(() => - { - var e = source.GetEnumerator(); - var n = count; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (n == 0) - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, x => tcs.TrySetResult(x)); - }); - else - { - --n; - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (!res) - tcs.TrySetResult(false); - else - f(tcs, ct); - }); - }); - } - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SkipWhile(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Create(() => - { - var e = source.GetEnumerator(); - var skipping = true; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (skipping) - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var result = false; - try - { - result = predicate(e.Current); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - if (result) - f(tcs, ct); - else - { - skipping = false; - tcs.TrySetResult(true); - } - } - else - tcs.TrySetResult(false); - }); - }); - else - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, x => tcs.TrySetResult(x)); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SkipWhile(this IAsyncEnumerable source, Func predicate) - { - if (source == null) - throw new ArgumentNullException("source"); - if (predicate == null) - throw new ArgumentNullException("predicate"); - - return Create(() => - { - var e = source.GetEnumerator(); - var skipping = true; - var index = 0; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (skipping) - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var result = false; - try - { - result = predicate(e.Current, index++); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - if (result) - f(tcs, ct); - else - { - skipping = false; - tcs.TrySetResult(true); - } - } - else - tcs.TrySetResult(false); - }); - }); - else - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, x => tcs.TrySetResult(x)); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => e.Current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable DefaultIfEmpty(this IAsyncEnumerable source, TSource defaultValue) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Create(() => - { - var done = false; - var hasElements = false; - var e = source.GetEnumerator(); - var current = default(TSource); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (done) - tcs.TrySetResult(false); - else - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - hasElements = true; - current = e.Current; - tcs.TrySetResult(true); - } - else - { - done = true; - - if (!hasElements) - { - current = defaultValue; - tcs.TrySetResult(true); - } - else - tcs.TrySetResult(false); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable DefaultIfEmpty(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.DefaultIfEmpty(default(TSource)); - } - - public static IAsyncEnumerable Distinct(this IAsyncEnumerable source, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Defer(() => - { - var set = new HashSet(comparer); - return source.Where(set.Add); - }); - } - - public static IAsyncEnumerable Distinct(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Distinct(EqualityComparer.Default); - } - - public static IAsyncEnumerable Reverse(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Create(() => - { - var e = source.GetEnumerator(); - var stack = default(Stack); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - return Create( - (ct, tcs) => - { - if (stack == null) - { - Create(() => e).Aggregate(new Stack(), (s, x) => { s.Push(x); return s; }, cts.Token).ContinueWith(t => - { - t.Handle(tcs, res => - { - stack = res; - tcs.TrySetResult(stack.Count > 0); - }); - }, cts.Token); - } - else - { - stack.Pop(); - tcs.TrySetResult(stack.Count > 0); - } - - return tcs.Task.UsingEnumerator(e); - }, - () => stack.Peek(), - d.Dispose - ); - }); - } - - public static IOrderedAsyncEnumerable OrderBy(this IAsyncEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return new OrderedAsyncEnumerable( - Create(() => - { - var current = default(IEnumerable); - - return Create( - ct => - { - var tcs = new TaskCompletionSource(); - if (current == null) - { - source.ToList(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - current = res; - tcs.TrySetResult(true); - }); - }); - } - else - tcs.TrySetResult(false); - return tcs.Task; - }, - () => current, - () => { } - ); - }), - keySelector, - comparer - ); - } - - public static IOrderedAsyncEnumerable OrderBy(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.OrderBy(keySelector, Comparer.Default); - } - - public static IOrderedAsyncEnumerable OrderByDescending(this IAsyncEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.OrderBy(keySelector, new ReverseComparer(comparer)); - } - - public static IOrderedAsyncEnumerable OrderByDescending(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.OrderByDescending(keySelector, Comparer.Default); - } - - public static IOrderedAsyncEnumerable ThenBy(this IOrderedAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.ThenBy(keySelector, Comparer.Default); - } - - public static IOrderedAsyncEnumerable ThenBy(this IOrderedAsyncEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.CreateOrderedEnumerable(keySelector, comparer, false); - } - - public static IOrderedAsyncEnumerable ThenByDescending(this IOrderedAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.ThenByDescending(keySelector, Comparer.Default); - } - - public static IOrderedAsyncEnumerable ThenByDescending(this IOrderedAsyncEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.CreateOrderedEnumerable(keySelector, comparer, true); - } - - static IEnumerable> GroupUntil(this IEnumerable source, Func keySelector, Func elementSelector, IComparer comparer) - { - var group = default(EnumerableGrouping); - foreach (var x in source) - { - var key = keySelector(x); - if (group == null || comparer.Compare(group.Key, key) != 0) - { - group = new EnumerableGrouping(key); - yield return group; - } - group.Add(elementSelector(x)); - } - } - - class OrderedAsyncEnumerable : IOrderedAsyncEnumerable - { - private readonly IAsyncEnumerable> equivalenceClasses; - private readonly Func keySelector; - private readonly IComparer comparer; - - public OrderedAsyncEnumerable(IAsyncEnumerable> equivalenceClasses, Func keySelector, IComparer comparer) - { - this.equivalenceClasses = equivalenceClasses; - this.keySelector = keySelector; - this.comparer = comparer; - } - - public IOrderedAsyncEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending) - { - if (descending) - comparer = new ReverseComparer(comparer); - - return new OrderedAsyncEnumerable(Classes(), keySelector, comparer); - } - - IAsyncEnumerable> Classes() - { - return Create(() => - { - var e = equivalenceClasses.GetEnumerator(); - var list = new List>(); - var e1 = default(IEnumerator>); - - var cts = new CancellationTokenDisposable(); - var d1 = new AssignableDisposable(); - var d = new CompositeDisposable(cts, e, d1); - - var f = default(Action, CancellationToken>); - var g = default(Action, CancellationToken>); - - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - foreach (var group in e.Current.OrderBy(keySelector, comparer).GroupUntil(keySelector, x => x, comparer)) - list.Add(group); - f(tcs, ct); - } - catch (Exception exception) - { - tcs.TrySetException(exception); - return; - } - } - else - { - e.Dispose(); - - e1 = list.GetEnumerator(); - d1.Disposable = e1; - - g(tcs, ct); - } - }); - }); - }; - - g = (tcs, ct) => - { - var res = false; - try - { - res = e1.MoveNext(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - tcs.TrySetResult(res); - }; - - return Create( - (ct, tcs) => - { - if (e1 != null) - { - g(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e1); - } - else - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - } - }, - () => e1.Current, - d.Dispose - ); - }); - } - - public IAsyncEnumerator GetEnumerator() - { - return Classes().SelectMany(x => x.ToAsyncEnumerable()).GetEnumerator(); - } - } - - class ReverseComparer : IComparer - { - IComparer comparer; - - public ReverseComparer(IComparer comparer) - { - this.comparer = comparer; - } - - public int Compare(T x, T y) - { - return -comparer.Compare(x, y); - } - } - - public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Create(() => - { - var gate = new object(); - - var e = source.GetEnumerator(); - var count = 1; - - var map = new Dictionary>(comparer); - var list = new List>(); - - var index = 0; - - var current = default(IAsyncGrouping); - var faulted = default(Exception); - - var task = default(Task); - - var cts = new CancellationTokenDisposable(); - var refCount = new Disposable( - () => - { - if (Interlocked.Decrement(ref count) == 0) - e.Dispose(); - } - ); - var d = new CompositeDisposable(cts, refCount); - - var iterateSource = default(Func>); - iterateSource = ct => - { - var tcs = default(TaskCompletionSource); - lock (gate) - { - if (task != null) - { - return task; - } - else - { - tcs = new TaskCompletionSource(); - task = tcs.Task.UsingEnumerator(e); - } - } - - if (faulted != null) - { - tcs.TrySetException(faulted); - return task; - } - - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, - res => - { - if (res) - { - var key = default(TKey); - var element = default(TElement); - - var cur = e.Current; - try - { - key = keySelector(cur); - element = elementSelector(cur); - } - catch (Exception exception) - { - foreach (var v in map.Values) - v.Error(exception); - - tcs.TrySetException(exception); - return; - } - - var group = default(Grouping); - if (!map.TryGetValue(key, out group)) - { - group = new Grouping(key, iterateSource, refCount); - map.Add(key, group); - lock (list) - list.Add(group); - - Interlocked.Increment(ref count); - } - group.Add(element); - } - - tcs.TrySetResult(res); - }, - ex => - { - foreach (var v in map.Values) - v.Error(ex); - - faulted = ex; - tcs.TrySetException(ex); - } - ); - - lock (gate) - { - task = null; - } - }); - - return tcs.Task.UsingEnumerator(e); - }; - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - iterateSource(ct).ContinueWith(t => - { - t.Handle(tcs, - res => - { - current = null; - lock (list) - { - if (index < list.Count) - current = list[index++]; - } - - if (current != null) - { - tcs.TrySetResult(true); - } - else - { - if (res) - f(tcs, ct); - else - tcs.TrySetResult(false); - } - } - ); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task; - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - - return source.GroupBy(keySelector, elementSelector, EqualityComparer.Default); - } - - public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.GroupBy(keySelector, x => x, comparer); - } - - public static IAsyncEnumerable> GroupBy(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.GroupBy(keySelector, x => x, EqualityComparer.Default); - } - - public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.GroupBy(keySelector, elementSelector, comparer).Select(g => resultSelector(g.Key, g)); - } - - public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (elementSelector == null) - throw new ArgumentNullException("elementSelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return source.GroupBy(keySelector, elementSelector, EqualityComparer.Default).Select(g => resultSelector(g.Key, g)); - } - - public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.GroupBy(keySelector, x => x, comparer).Select(g => resultSelector(g.Key, g)); - } - - public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return source.GroupBy(keySelector, x => x, EqualityComparer.Default).Select(g => resultSelector(g.Key, g)); - } - - class Grouping : IAsyncGrouping - { - private readonly Func> iterateSource; - private readonly IDisposable sourceDisposable; - private readonly List elements = new List(); - private bool done = false; - private Exception exception = null; - - public Grouping(TKey key, Func> iterateSource, IDisposable sourceDisposable) - { - this.iterateSource = iterateSource; - this.sourceDisposable = sourceDisposable; - Key = key; - } - - public TKey Key - { - get; - private set; - } - - public void Add(TElement element) - { - lock (elements) - elements.Add(element); - } - - public void Error(Exception exception) - { - done = true; - this.exception = exception; - } - - public IAsyncEnumerator GetEnumerator() - { - var index = -1; - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, sourceDisposable); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - var size = 0; - lock (elements) - size = elements.Count; - - if (index < size) - { - tcs.TrySetResult(true); - } - else if (done) - { - if (exception != null) - tcs.TrySetException(exception); - else - tcs.TrySetResult(false); - } - else - { - iterateSource(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - f(tcs, ct); - else - tcs.TrySetResult(false); - }); - }); - } - }; - - return Create( - (ct, tcs) => - { - ++index; - f(tcs, cts.Token); - return tcs.Task; - }, - () => elements[index], - d.Dispose - ); - } - } - - #region Ix - - public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - - return DoHelper(source, onNext, _ => { }, () => { }); - } - - public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext, Action onCompleted) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onCompleted == null) - throw new ArgumentNullException("onCompleted"); - - return DoHelper(source, onNext, _ => { }, onCompleted); - } - - public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext, Action onError) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onError == null) - throw new ArgumentNullException("onError"); - - return DoHelper(source, onNext, onError, () => { }); - } - - public static IAsyncEnumerable Do(this IAsyncEnumerable source, Action onNext, Action onError, Action onCompleted) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onError == null) - throw new ArgumentNullException("onError"); - if (onCompleted == null) - throw new ArgumentNullException("onCompleted"); - - return DoHelper(source, onNext, onError, onCompleted); - } - -#if !NO_RXINTERFACES - public static IAsyncEnumerable Do(this IAsyncEnumerable source, IObserver observer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (observer == null) - throw new ArgumentNullException("observer"); - - return DoHelper(source, observer.OnNext, observer.OnError, observer.OnCompleted); - } -#endif - - private static IAsyncEnumerable DoHelper(this IAsyncEnumerable source, Action onNext, Action onError, Action onCompleted) - { - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var current = default(TSource); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - if (!t.IsCanceled) - { - try - { - if (t.IsFaulted) - { - onError(t.Exception); - } - else if (!t.Result) - { - onCompleted(); - } - else - { - current = e.Current; - onNext(current); - } - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - } - - t.Handle(tcs, res => - { - tcs.TrySetResult(res); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static void ForEach(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - source.ForEachAsync(action, cancellationToken).Wait(cancellationToken); - } - - public static Task ForEachAsync(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - return source.ForEachAsync((x, i) => action(x), cancellationToken); - } - - public static void ForEach(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - source.ForEachAsync(action, cancellationToken).Wait(cancellationToken); - } - - public static Task ForEachAsync(this IAsyncEnumerable source, Action action, CancellationToken cancellationToken) - { - if (source == null) - throw new ArgumentNullException("source"); - if (action == null) - throw new ArgumentNullException("action"); - - var tcs = new TaskCompletionSource(); - - var e = source.GetEnumerator(); - - var i = 0; - - var f = default(Action); - f = ct => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - try - { - action(e.Current, i++); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - f(ct); - } - else - tcs.TrySetResult(true); - }); - }); - }; - - f(cancellationToken); - - return tcs.Task.UsingEnumerator(e); - } - - public static IAsyncEnumerable Repeat(this IAsyncEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Create(() => - { - var e = default(IAsyncEnumerator); - var a = new AssignableDisposable(); - var n = count; - var current = default(TSource); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, a); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (e == null) - { - if (n-- == 0) - { - tcs.TrySetResult(false); - return; - } - - try - { - e = source.GetEnumerator(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - a.Disposable = e; - } - - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - current = e.Current; - tcs.TrySetResult(true); - } - else - { - e = null; - f(tcs, ct); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(d); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Repeat(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Create(() => - { - var e = default(IAsyncEnumerator); - var a = new AssignableDisposable(); - var current = default(TSource); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, a); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (e == null) - { - try - { - e = source.GetEnumerator(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - a.Disposable = e; - } - - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - current = e.Current; - tcs.TrySetResult(true); - } - else - { - e = null; - f(tcs, ct); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(d); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable IgnoreElements(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (!res) - { - tcs.TrySetResult(false); - return; - } - - f(tcs, ct); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => { throw new InvalidOperationException(); }, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable StartWith(this IAsyncEnumerable source, params TSource[] values) - { - if (source == null) - throw new ArgumentNullException("source"); - - return values.ToAsyncEnumerable().Concat(source); - } - - public static IAsyncEnumerable> Buffer(this IAsyncEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count <= 0) - throw new ArgumentOutOfRangeException("count"); - - return source.Buffer_(count, count); - } - - public static IAsyncEnumerable> Buffer(this IAsyncEnumerable source, int count, int skip) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count <= 0) - throw new ArgumentOutOfRangeException("count"); - if (skip <= 0) - throw new ArgumentOutOfRangeException("skip"); - - return source.Buffer_(count, skip); - } - - private static IAsyncEnumerable> Buffer_(this IAsyncEnumerable source, int count, int skip) - { - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var buffers = new Queue>(); - - var i = 0; - - var current = default(IList); - var stopped = false; - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (!stopped) - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var item = e.Current; - - if (i++ % skip == 0) - buffers.Enqueue(new List(count)); - - foreach (var buffer in buffers) - buffer.Add(item); - - if (buffers.Count > 0 && buffers.Peek().Count == count) - { - current = buffers.Dequeue(); - tcs.TrySetResult(true); - return; - } - - f(tcs, ct); - } - else - { - stopped = true; - e.Dispose(); - - f(tcs, ct); - } - }); - }); - } - else - { - if (buffers.Count > 0) - { - current = buffers.Dequeue(); - tcs.TrySetResult(true); - } - else - { - tcs.TrySetResult(false); - } - } - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Distinct(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return Defer(() => - { - var set = new HashSet(comparer); - return source.Where(item => set.Add(keySelector(item))); - }); - } - - public static IAsyncEnumerable Distinct(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.Distinct(keySelector, EqualityComparer.Default); - } - - public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.DistinctUntilChanged_(x => x, EqualityComparer.Default); - } - - public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.DistinctUntilChanged_(x => x, comparer); - } - - public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.DistinctUntilChanged_(keySelector, EqualityComparer.Default); - } - - public static IAsyncEnumerable DistinctUntilChanged(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.DistinctUntilChanged_(keySelector, comparer); - } - - private static IAsyncEnumerable DistinctUntilChanged_(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - { - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var currentKey = default(TKey); - var hasCurrentKey = false; - var current = default(TSource); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var item = e.Current; - var key = default(TKey); - var comparerEquals = false; - - try - { - key = keySelector(item); - - if (hasCurrentKey) - { - comparerEquals = comparer.Equals(currentKey, key); - } - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - if (!hasCurrentKey || !comparerEquals) - { - hasCurrentKey = true; - currentKey = key; - - current = item; - tcs.TrySetResult(true); - } - else - { - f(tcs, ct); - } - } - else - { - tcs.TrySetResult(false); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Expand(this IAsyncEnumerable source, Func> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => - { - var e = default(IAsyncEnumerator); - - var cts = new CancellationTokenDisposable(); - var a = new AssignableDisposable(); - var d = new CompositeDisposable(cts, a); - - var queue = new Queue>(); - queue.Enqueue(source); - - var current = default(TSource); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (e == null) - { - if (queue.Count > 0) - { - var src = queue.Dequeue(); - - try - { - e = src.GetEnumerator(); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - a.Disposable = e; - f(tcs, ct); - } - else - { - tcs.TrySetResult(false); - } - } - else - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var item = e.Current; - - var next = default(IAsyncEnumerable); - try - { - next = selector(item); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - queue.Enqueue(next); - current = item; - tcs.TrySetResult(true); - } - else - { - e = null; - f(tcs, ct); - } - }); - }); - } - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(a); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Scan(this IAsyncEnumerable source, TAccumulate seed, Func accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var acc = seed; - var current = default(TAccumulate); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (!res) - { - tcs.TrySetResult(false); - return; - } - - var item = e.Current; - try - { - acc = accumulator(acc, item); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - current = acc; - tcs.TrySetResult(true); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable Scan(this IAsyncEnumerable source, Func accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var hasSeed = false; - var acc = default(TSource); - var current = default(TSource); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (!res) - { - tcs.TrySetResult(false); - return; - } - - var item = e.Current; - - if (!hasSeed) - { - hasSeed = true; - acc = item; - f(tcs, ct); - return; - } - - try - { - acc = accumulator(acc, item); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - current = acc; - tcs.TrySetResult(true); - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable TakeLast(this IAsyncEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var q = new Queue(count); - var done = false; - var current = default(TSource); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - if (!done) - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var item = e.Current; - - if (q.Count >= count) - q.Dequeue(); - q.Enqueue(item); - } - else - { - done = true; - e.Dispose(); - } - - f(tcs, ct); - }); - }); - } - else - { - if (q.Count > 0) - { - current = q.Dequeue(); - tcs.TrySetResult(true); - } - else - { - tcs.TrySetResult(false); - } - } - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - public static IAsyncEnumerable SkipLast(this IAsyncEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Create(() => - { - var e = source.GetEnumerator(); - - var cts = new CancellationTokenDisposable(); - var d = new CompositeDisposable(cts, e); - - var q = new Queue(); - var current = default(TSource); - - var f = default(Action, CancellationToken>); - f = (tcs, ct) => - { - e.MoveNext(ct).ContinueWith(t => - { - t.Handle(tcs, res => - { - if (res) - { - var item = e.Current; - - q.Enqueue(item); - if (q.Count > count) - { - current = q.Dequeue(); - tcs.TrySetResult(true); - } - else - { - f(tcs, ct); - } - } - else - { - tcs.TrySetResult(false); - } - }); - }); - }; - - return Create( - (ct, tcs) => - { - f(tcs, cts.Token); - return tcs.Task.UsingEnumerator(e); - }, - () => current, - d.Dispose - ); - }); - } - - #endregion - } -} diff --git a/Ix/System.Interactive.Async/AsyncEnumerator.cs b/Ix/System.Interactive.Async/AsyncEnumerator.cs deleted file mode 100644 index 003141f..0000000 --- a/Ix/System.Interactive.Async/AsyncEnumerator.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Linq; -using System.Threading.Tasks; -using System.Threading; - -namespace System.Collections.Generic -{ - public static class AsyncEnumerator - { - /// - /// Advances the enumerator to the next element in the sequence, returning the result asynchronously. - /// - /// - /// Task containing the result of the operation: true if the enumerator was successfully advanced - /// to the next element; false if the enumerator has passed the end of the sequence. - /// - public static Task MoveNext(this IAsyncEnumerator enumerator) - { - if (enumerator == null) - throw new ArgumentNullException("enumerator"); - - return enumerator.MoveNext(CancellationToken.None); - } - } -} diff --git a/Ix/System.Interactive.Async/Disposables.cs b/Ix/System.Interactive.Async/Disposables.cs deleted file mode 100644 index 05d5554..0000000 --- a/Ix/System.Interactive.Async/Disposables.cs +++ /dev/null @@ -1,89 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Threading; - -namespace System.Linq -{ - class CancellationTokenDisposable : IDisposable - { - private CancellationTokenSource cts = new CancellationTokenSource(); - - public CancellationToken Token { get { return cts.Token; } } - - public void Dispose() - { - if (!cts.IsCancellationRequested) - cts.Cancel(); - } - } - - class CompositeDisposable : IDisposable - { - private readonly IDisposable[] _dispose; - - public CompositeDisposable(params IDisposable[] dispose) - { - _dispose = dispose; - } - - public void Dispose() - { - foreach (var d in _dispose) - d.Dispose(); - } - } - - class AssignableDisposable : IDisposable - { - private object _gate = new object(); - private IDisposable _disposable; - private bool _disposed; - - public IDisposable Disposable - { - set - { - lock (_gate) - { - if (_disposable != null) - _disposable.Dispose(); - - _disposable = value; - - if (_disposed) - _disposable.Dispose(); - } - } - } - - public void Dispose() - { - lock (_gate) - { - if (!_disposed) - { - _disposed = true; - - if (_disposable != null) - _disposable.Dispose(); - } - } - } - } - - class Disposable : IDisposable - { - private readonly Action _dispose; - - public Disposable(Action dispose) - { - _dispose = dispose; - } - - public void Dispose() - { - _dispose(); - } - } -} diff --git a/Ix/System.Interactive.Async/EnumerableGrouping.cs b/Ix/System.Interactive.Async/EnumerableGrouping.cs deleted file mode 100644 index 69469c8..0000000 --- a/Ix/System.Interactive.Async/EnumerableGrouping.cs +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; - -namespace System.Linq -{ - class EnumerableGrouping : IGrouping - { - List elements = new List(); - - public EnumerableGrouping(TKey key) - { - Key = key; - } - - public void Add(TElement element) - { - elements.Add(element); - } - - public TKey Key { get; private set; } - - public IEnumerator GetEnumerator() - { - return elements.GetEnumerator(); - } - - System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { - return this.GetEnumerator(); - } - } -} diff --git a/Ix/System.Interactive.Async/IAsyncEnumerable.cs b/Ix/System.Interactive.Async/IAsyncEnumerable.cs deleted file mode 100644 index 8d892e1..0000000 --- a/Ix/System.Interactive.Async/IAsyncEnumerable.cs +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; - -namespace System.Collections.Generic -{ - /// - /// Asynchronous version of the IEnumerable<T> interface, allowing elements of the - /// enumerable sequence to be retrieved asynchronously. - /// - /// Element type. - public interface IAsyncEnumerable< -#if DESKTOPCLR40 || SILVERLIGHT4 - out -#endif - T> - { - /// - /// Gets an asynchronous enumerator over the sequence. - /// - /// Enumerator for asynchronous enumeration over the sequence. - IAsyncEnumerator GetEnumerator(); - } -} diff --git a/Ix/System.Interactive.Async/IAsyncEnumerator.cs b/Ix/System.Interactive.Async/IAsyncEnumerator.cs deleted file mode 100644 index 72cfdbc..0000000 --- a/Ix/System.Interactive.Async/IAsyncEnumerator.cs +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Threading.Tasks; -using System.Threading; - -namespace System.Collections.Generic -{ - /// - /// Asynchronous version of the IEnumerator<T> interface, allowing elements to be - /// retrieved asynchronously. - /// - /// Element type. - public interface IAsyncEnumerator< -#if DESKTOPCLR40 || SILVERLIGHT4 - out -#endif - T> : IDisposable - { - /// - /// Advances the enumerator to the next element in the sequence, returning the result asynchronously. - /// - /// Cancellation token that can be used to cancel the operation. - /// - /// Task containing the result of the operation: true if the enumerator was successfully advanced - /// to the next element; false if the enumerator has passed the end of the sequence. - /// - Task MoveNext(CancellationToken cancellationToken); - - /// - /// Gets the current element in the iteration. - /// - T Current { get; } - } -} diff --git a/Ix/System.Interactive.Async/IAsyncGrouping.cs b/Ix/System.Interactive.Async/IAsyncGrouping.cs deleted file mode 100644 index 61abc60..0000000 --- a/Ix/System.Interactive.Async/IAsyncGrouping.cs +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; - -namespace System.Linq -{ - public interface IAsyncGrouping< -#if DESKTOPCLR4 || SILVERLIGHT4 - out -#endif - TKey, -#if DESKTOPCLR4 || SILVERLIGHT4 - out -#endif - TElement> : IAsyncEnumerable - { - TKey Key { get; } - } -} diff --git a/Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs b/Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs deleted file mode 100644 index a1e430d..0000000 --- a/Ix/System.Interactive.Async/IOrderedAsyncEnumerable.cs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; - -namespace System.Linq -{ - public interface IOrderedAsyncEnumerable< -#if DESKTOPCLR4 || SILVERLIGHT4 - out -#endif - TElement> : IAsyncEnumerable - { - IOrderedAsyncEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending); - } -} diff --git a/Ix/System.Interactive.Async/Properties/AssemblyInfo.cs b/Ix/System.Interactive.Async/Properties/AssemblyInfo.cs deleted file mode 100644 index b887de0..0000000 --- a/Ix/System.Interactive.Async/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,37 +0,0 @@ -using System; -using System.Reflection; -using System.Resources; -using System.Runtime.InteropServices; -using System.Security; - -[assembly: AssemblyTitle("System.Interactive.Async")] -// Notice: same description as in the .nuspec files; see Source/Interactive Extensions/Setup/NuGet -[assembly: AssemblyDescription("Interactive Extensions Async Library used to express queries over asynchronous enumerable sequences.")] -#if DEBUG -[assembly: AssemblyConfiguration("Debug")] -#else -[assembly: AssemblyConfiguration("Retail")] -#endif -[assembly: AssemblyCompany("Microsoft Corporation")] -#if STABLE -[assembly: AssemblyProduct("Interactive Extensions")] -#else -[assembly: AssemblyProduct("Interactive Extensions (Experimental Release)")] -#endif -[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")] -[assembly: NeutralResourcesLanguage("en-US")] - -#if !PLIB -[assembly: ComVisible(false)] -#endif - -[assembly: CLSCompliant(true)] - -#if DESKTOPCLR && NO_CODECOVERAGE -[assembly: AllowPartiallyTrustedCallers] -#endif - -// -// Note: Assembly (file) version numbers get inserted by the build system on the fly. Inspect the Team Build workflows -// and the custom activity in Build/Source/Activities/AppendVersionInfo.cs for more information. -// diff --git a/Ix/System.Interactive.Async/System.Interactive.Async.csproj b/Ix/System.Interactive.Async/System.Interactive.Async.csproj deleted file mode 100644 index b8143b2..0000000 --- a/Ix/System.Interactive.Async/System.Interactive.Async.csproj +++ /dev/null @@ -1,47 +0,0 @@ - - - - Debug - AnyCPU - 8.0.30703 - 2.0 - {7269A578-326A-4C3E-9874-A2D2600095BC} - Library - Properties - System.Interactive.Async - System.Interactive.Async - v4.0 - 512 - - - - $(OutputPath)\$(AssemblyName).XML - - - Profile1 - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/Ix/System.Interactive.Async/TaskExt.cs b/Ix/System.Interactive.Async/TaskExt.cs deleted file mode 100644 index 5f714ad..0000000 --- a/Ix/System.Interactive.Async/TaskExt.cs +++ /dev/null @@ -1,134 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; - -namespace System.Threading.Tasks -{ - static class TaskExt - { - public static Task Return(T value, CancellationToken cancellationToken) - { - var tcs = new TaskCompletionSource(); - tcs.TrySetResult(value); - return tcs.Task; - } - - public static Task Throw(Exception exception, CancellationToken cancellationToken) - { - var tcs = new TaskCompletionSource(); - tcs.TrySetException(exception); - return tcs.Task; - } - - public static void Handle(this Task task, TaskCompletionSource tcs, Action success) - { - Handle(task, tcs, success, ex => tcs.TrySetException(ex), () => tcs.TrySetCanceled()); - } - - public static void Handle(this Task task, TaskCompletionSource tcs, Action success, Action error) - { - Handle(task, tcs, success, error, () => tcs.TrySetCanceled()); - } - - public static void Handle(this Task task, TaskCompletionSource tcs, Action success, Action error, Action canceled) - { - if (task.IsFaulted) - error(task.Exception); - else if (task.IsCanceled) - canceled(); - else if (task.IsCompleted) - success(task.Result); - } - - public static Task UsingEnumerator(this Task task, IDisposable disposable) - { - task.ContinueWith(t => - { - if (t.IsFaulted) - { - var ignored = t.Exception; // don't remove! - } - - if (t.IsFaulted || t.IsCanceled || !t.Result) - disposable.Dispose(); - }, TaskContinuationOptions.ExecuteSynchronously); - - return task; - } - - public static Task UsingEnumeratorSync(this Task task, IDisposable disposable) - { - var tcs = new TaskCompletionSource(); - - task.ContinueWith(t => - { - if (t.IsFaulted || t.IsCanceled || !t.Result) - disposable.Dispose(); // TODO: Check whether we need exception handling here! - - t.Handle(tcs, res => tcs.TrySetResult(res)); - }, TaskContinuationOptions.ExecuteSynchronously); - - return tcs.Task; - } - - public static Task Finally(this Task task, Action action) - { - task.ContinueWith(t => - { - if (t.IsFaulted) - { - var ignored = t.Exception; // don't remove! - } - - action(); - }, TaskContinuationOptions.ExecuteSynchronously); - - return task; - } - - public static Task Zip(this Task t1, Task t2, Func f) - { - var gate = new object(); - var tcs = new TaskCompletionSource(); - - var i = 2; - var complete = new Action(t => - { - if (Interlocked.Decrement(ref i) == 0) - { - var exs = new List(); - if (t1.IsFaulted) - exs.Add(t1.Exception); - if (t2.IsFaulted) - exs.Add(t2.Exception); - - if (exs.Count > 0) - tcs.TrySetException(exs); - else if (t1.IsCanceled || t2.IsCanceled) - tcs.TrySetCanceled(); - else - { - var res = default(V); - try - { - res = f(t1.Result, t2.Result); - } - catch (Exception ex) - { - tcs.TrySetException(ex); - return; - } - - tcs.TrySetResult(res); - } - } - }); - - t1.ContinueWith(complete); - t2.ContinueWith(complete); - - return tcs.Task; - } - } -} diff --git a/Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs b/Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs deleted file mode 100644 index 03b49a8..0000000 --- a/Ix/System.Interactive.Providers/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,37 +0,0 @@ -using System; -using System.Reflection; -using System.Resources; -using System.Runtime.InteropServices; -using System.Security; - -[assembly: AssemblyTitle("System.Interactive.Providers")] -// Notice: same description as in the .nuspec files; see Source/Interactive Extensions/Setup/NuGet -[assembly: AssemblyDescription("Interactive Extensions Providers Library used to build query providers and express queries over enumerable sequences.")] -#if DEBUG -[assembly: AssemblyConfiguration("Debug")] -#else -[assembly: AssemblyConfiguration("Retail")] -#endif -[assembly: AssemblyCompany("Microsoft Corporation")] -#if STABLE -[assembly: AssemblyProduct("Interactive Extensions")] -#else -[assembly: AssemblyProduct("Interactive Extensions (Experimental Release)")] -#endif -[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")] -[assembly: NeutralResourcesLanguage("en-US")] - -#if !PLIB -[assembly: ComVisible(false)] -#endif - -[assembly: CLSCompliant(true)] - -#if DESKTOPCLR && NO_CODECOVERAGE -[assembly: AllowPartiallyTrustedCallers] -#endif - -// -// Note: Assembly (file) version numbers get inserted by the build system on the fly. Inspect the Team Build workflows -// and the custom activity in Build/Source/Activities/AppendVersionInfo.cs for more information. -// diff --git a/Ix/System.Interactive.Providers/QueryableEx.cs b/Ix/System.Interactive.Providers/QueryableEx.cs deleted file mode 100644 index 20f7ec8..0000000 --- a/Ix/System.Interactive.Providers/QueryableEx.cs +++ /dev/null @@ -1,2327 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System.Collections.Generic; -using System.ComponentModel; -using System.Globalization; -using System.Linq.Expressions; -using System.Reflection; - -namespace System.Linq -{ - /// - /// Provides a set of additional static methods that allow querying enumerable sequences. - /// - public static class QueryableEx - { - /// - /// Determines whether an enumerable sequence is empty. - /// - /// Source sequence element type. - /// Source sequence. - /// true if the sequence is empty; false otherwise. - public static bool IsEmpty(this IQueryable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.Execute( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static bool IsEmpty(IEnumerable source) - { - return EnumerableEx.IsEmpty(source); - } -#pragma warning restore 1591 - - /// - /// Returns the minimum value in the enumerable sequence by using the specified comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Comparer used to determine the minimum value. - /// Minimum value in the sequence. - public static TSource Min(this IQueryable source, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.Execute( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(comparer, typeof(IComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static TSource Min(IEnumerable source, IComparer comparer) - { - return EnumerableEx.Min(source, comparer); - } -#pragma warning restore 1591 - - /// - /// Returns the elements with the minimum key value by using the default comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// List with the elements that share the same minimum key value. - public static IList MinBy(this IQueryable source, Expression> keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.Provider.Execute>( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IList MinBy(IEnumerable source, Func keySelector) - { - return EnumerableEx.MinBy(source, keySelector); - } -#pragma warning restore 1591 - - /// - /// Returns the elements with the minimum key value by using the specified comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// Comparer used to determine the minimum key value. - /// List with the elements that share the same minimum key value. - public static IList MinBy(this IQueryable source, Expression> keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.Execute>( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector, - Expression.Constant(comparer, typeof(IComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IList MinBy(IEnumerable source, Func keySelector, IComparer comparer) - { - return EnumerableEx.MinBy(source, keySelector, comparer); - } -#pragma warning restore 1591 - - /// - /// Returns the maximum value in the enumerable sequence by using the specified comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Comparer used to determine the maximum value. - /// Maximum value in the sequence. - public static TSource Max(this IQueryable source, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.Execute( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(comparer, typeof(IComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static TSource Max(IEnumerable source, IComparer comparer) - { - return EnumerableEx.Max(source, comparer); - } -#pragma warning restore 1591 - - /// - /// Returns the elements with the maximum key value by using the default comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// List with the elements that share the same maximum key value. - public static IList MaxBy(this IQueryable source, Expression> keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.Provider.Execute>( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IList MaxBy(IEnumerable source, Func keySelector) - { - return EnumerableEx.MaxBy(source, keySelector); - } -#pragma warning restore 1591 - - /// - /// Returns the elements with the minimum key value by using the specified comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// Comparer used to determine the maximum key value. - /// List with the elements that share the same maximum key value. - public static IList MaxBy(this IQueryable source, Expression> keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.Execute>( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector, - Expression.Constant(comparer, typeof(IComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IList MaxBy(IEnumerable source, Func keySelector, IComparer comparer) - { - return EnumerableEx.MaxBy(source, keySelector, comparer); - } -#pragma warning restore 1591 - - /// - /// Shares the source sequence within a selector function where each enumerator can fetch the next element from the source sequence. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Selector function with shared access to the source sequence for each enumerator. - /// Sequence resulting from applying the selector function to the shared view over the source sequence. - public static IQueryable Share(this IQueryable source, Expression, IEnumerable>> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), - source.Expression, - selector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Share(IEnumerable source, Func, IEnumerable> selector) - { - return EnumerableEx.Share(source, selector); - } -#pragma warning restore 1591 - - /// - /// Publishes the source sequence within a selector function where each enumerator can obtain a view over a tail of the source sequence. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Selector function with published access to the source sequence for each enumerator. - /// Sequence resulting from applying the selector function to the published view over the source sequence. - public static IQueryable Publish(this IQueryable source, Expression, IEnumerable>> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), - source.Expression, - selector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Publish(IEnumerable source, Func, IEnumerable> selector) - { - return EnumerableEx.Publish(source, selector); - } -#pragma warning restore 1591 - - /// - /// Memoizes the source sequence within a selector function where each enumerator can get access to all of the sequence's elements without causing multiple enumerations over the source. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Selector function with memoized access to the source sequence for each enumerator. - /// Sequence resulting from applying the selector function to the memoized view over the source sequence. - public static IQueryable Memoize(this IQueryable source, Expression, IEnumerable>> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), - source.Expression, - selector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Memoize(IEnumerable source, Func, IEnumerable> selector) - { - return EnumerableEx.Memoize(source, selector); - } -#pragma warning restore 1591 - - /// - /// Memoizes the source sequence within a selector function where a specified number of enumerators can get access to all of the sequence's elements without causing multiple enumerations over the source. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Number of enumerators that can access the underlying buffer. Once every enumerator has obtained an element from the buffer, the element is removed from the buffer. - /// Selector function with memoized access to the source sequence for a specified number of enumerators. - /// Sequence resulting from applying the selector function to the memoized view over the source sequence. - public static IQueryable Memoize(this IQueryable source, int readerCount, Expression, IEnumerable>> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), - source.Expression, - Expression.Constant(readerCount, typeof(int)), - selector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Memoize(IEnumerable source, int readerCount, Func, IEnumerable> selector) - { - return EnumerableEx.Memoize(source, readerCount, selector); - } -#pragma warning restore 1591 - - /// - /// Creates an enumerable sequence based on an enumerator factory function. - /// - /// Result sequence element type. - /// Query provider. - /// Enumerator factory function. - /// Sequence that will invoke the enumerator factory upon a call to GetEnumerator. - public static IQueryable Create(this IQueryProvider provider, Expression>> getEnumerator) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (getEnumerator == null) - throw new ArgumentNullException("getEnumerator"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - getEnumerator - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Create(Func> getEnumerator) - { - return EnumerableEx.Create(getEnumerator); - } -#pragma warning restore 1591 - - /// - /// Returns a sequence with a single element. - /// - /// Result sequence element type. - /// Query provider. - /// Single element of the resulting sequence. - /// Sequence with a single element. - public static IQueryable Return(this IQueryProvider provider, TResult value) - { - if (provider == null) - throw new ArgumentNullException("provider"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - Expression.Constant(value, typeof(TResult)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Return(TResult value) - { - return EnumerableEx.Return(value).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Returns a sequence that throws an exception upon enumeration. - /// - /// Result sequence element type. - /// Query provider. - /// Exception to throw upon enumerating the resulting sequence. - /// Sequence that throws the specified exception upon enumeration. - public static IQueryable Throw(this IQueryProvider provider, Exception exception) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (exception == null) - throw new ArgumentNullException("exception"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - Expression.Constant(exception, typeof(Exception)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Throw(Exception exception) - { - return EnumerableEx.Throw(exception).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Creates an enumerable sequence based on an enumerable factory function. - /// - /// Result sequence element type. - /// Query provider. - /// Enumerable factory function. - /// Sequence that will invoke the enumerable factory upon a call to GetEnumerator. - public static IQueryable Defer(this IQueryProvider provider, Expression>> enumerableFactory) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (enumerableFactory == null) - throw new ArgumentNullException("enumerableFactory"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - enumerableFactory - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Defer(Func> enumerableFactory) - { - return EnumerableEx.Defer(enumerableFactory).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence by mimicking a for loop. - /// - /// State type. - /// Result sequence element type. - /// Query provider. - /// Initial state of the generator loop. - /// Loop condition. - /// State update function to run after every iteration of the generator loop. - /// Result selector to compute resulting sequence elements. - /// Sequence obtained by running the generator loop, yielding computed elements. - public static IQueryable Generate(this IQueryProvider provider, TState initialState, Expression> condition, Expression> iterate, Expression> resultSelector) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (condition == null) - throw new ArgumentNullException("condition"); - if (iterate == null) - throw new ArgumentNullException("iterate"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TState), typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - Expression.Constant(initialState), - condition, - iterate, - resultSelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Generate(TState initialState, Func condition, Func iterate, Func resultSelector) - { - return EnumerableEx.Generate(initialState, condition, iterate, resultSelector).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage duration. - /// - /// Source element type. - /// Resource type. - /// Query provider. - /// Resource factory function. - /// Enumerable factory function, having access to the obtained resource. - /// Sequence whose use controls the lifetime of the associated obtained resource. - public static IQueryable Using(this IQueryProvider provider, Expression> resourceFactory, Expression>> enumerableFactory) where TResource : IDisposable - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (resourceFactory == null) - throw new ArgumentNullException("resourceFactory"); - if (enumerableFactory == null) - throw new ArgumentNullException("enumerableFactory"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResource)), - Expression.Constant(provider, typeof(IQueryProvider)), - resourceFactory, - enumerableFactory - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Using(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable - { - return EnumerableEx.Using(resourceFactory, enumerableFactory).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence by repeating the given value infinitely. - /// - /// Result sequence element type. - /// Query provider. - /// Value to repreat in the resulting sequence. - /// Sequence repeating the given value infinitely. - public static IEnumerable Repeat(this IQueryProvider provider, TResult value) - { - if (provider == null) - throw new ArgumentNullException("provider"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - Expression.Constant(value, typeof(TResult)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Repeat(TResult value) - { - return EnumerableEx.Repeat(value).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error. - /// - /// Source sequence element type. - /// Exception type to catch. - /// Source sequence. - /// Handler to invoke when an exception of the specified type occurs. - /// Source sequence, concatenated with an exception handler result sequence in case of an error. - public static IQueryable Catch(this IQueryable source, Expression>> handler) - where TException : Exception - { - if (source == null) - throw new ArgumentNullException("source"); - if (handler == null) - throw new ArgumentNullException("handler"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TException)), - source.Expression, - handler - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Catch(IEnumerable source, Func> handler) - where TException : Exception - { - return EnumerableEx.Catch(source, handler); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence that continues to concatenate source sequences while errors occur. - public static IQueryable Catch(this IQueryable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - sources.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Catch(IEnumerable> sources) - { - return EnumerableEx.Catch(sources); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. - /// - /// Source sequence element type. - /// Query provider. - /// Source sequences. - /// Sequence that continues to concatenate source sequences while errors occur. - public static IQueryable Catch(this IQueryProvider provider, params IEnumerable[] sources) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (sources == null) - throw new ArgumentNullException("sources"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - Expression.Constant(provider, typeof(IQueryProvider)), - GetSourceExpression(sources) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Catch(params IEnumerable[] sources) - { - return EnumerableEx.Catch(sources).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error. - /// - /// Source sequence element type. - /// First sequence. - /// Second sequence, concatenated to the result in case the first sequence completes exceptionally. - /// The first sequence, followed by the second sequence in case an error is produced. - public static IQueryable Catch(this IQueryable first, IEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return first.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - first.Expression, - GetSourceExpression(second) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Catch(IEnumerable first, IEnumerable second) - { - return EnumerableEx.Catch(first, second); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to run upon termination of the sequence, or when an enumerator is disposed. - /// Source sequence with guarantees on the invocation of the finally action. - public static IQueryable Finally(this IQueryable source, Expression finallyAction) - { - if (source == null) - throw new ArgumentNullException("source"); - if (finallyAction == null) - throw new ArgumentNullException("finallyAction"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - finallyAction - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Finally(IEnumerable source, Action finallyAction) - { - return EnumerableEx.Finally(source, finallyAction); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that concatenates both given sequences, regardless of whether an error occurs. - /// - /// Source sequence element type. - /// First sequence. - /// Second sequence. - /// Sequence concatenating the elements of both sequences, ignoring errors. - public static IQueryable OnErrorResumeNext(this IQueryable first, IEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return first.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - first.Expression, - GetSourceExpression(second) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable OnErrorResumeNext(IEnumerable first, IEnumerable second) - { - return EnumerableEx.OnErrorResumeNext(first, second); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. - /// - /// Source sequence element type. - /// Query provider. - /// Source sequences. - /// Sequence concatenating the elements of the given sequences, ignoring errors. - public static IEnumerable OnErrorResumeNext(this IQueryProvider provider, params IEnumerable[] sources) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (sources == null) - throw new ArgumentNullException("sources"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - Expression.Constant(provider, typeof(IQueryProvider)), - GetSourceExpression(sources) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable OnErrorResumeNext(params IEnumerable[] sources) - { - return EnumerableEx.OnErrorResumeNext(sources).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence concatenating the elements of the given sequences, ignoring errors. - public static IQueryable OnErrorResumeNext(this IQueryable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - sources.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable OnErrorResumeNext(IEnumerable> sources) - { - return EnumerableEx.OnErrorResumeNext(sources); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that retries enumerating the source sequence as long as an error occurs. - /// - /// Source sequence element type. - /// Source sequence. - /// Sequence concatenating the results of the source sequence as long as an error occurs. - public static IQueryable Retry(this IQueryable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Retry(IEnumerable source) - { - return EnumerableEx.Retry(source); - } -#pragma warning restore 1591 - - /// - /// Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified maximum number of retries. - /// - /// Source sequence element type. - /// Source sequence. - /// Maximum number of retries. - /// Sequence concatenating the results of the source sequence as long as an error occurs. - public static IQueryable Retry(this IQueryable source, int retryCount) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(retryCount, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Retry(IEnumerable source, int retryCount) - { - return EnumerableEx.Retry(source, retryCount); - } -#pragma warning restore 1591 - - /// - /// Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. - /// - /// Result sequence element type. - /// Query provider. - /// Loop condition. - /// Sequence to repeat while the condition evaluates true. - /// Sequence generated by repeating the given sequence while the condition evaluates to true. - public static IQueryable While(this IQueryProvider provider, Expression> condition, IEnumerable source) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (condition == null) - throw new ArgumentNullException("condition"); - if (source == null) - throw new ArgumentNullException("source"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - condition, - GetSourceExpression(source) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable While(Func condition, IEnumerable source) - { - return EnumerableEx.While(condition, source).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Returns an enumerable sequence based on the evaluation result of the given condition. - /// - /// Result sequence element type. - /// Query provider. - /// Condition to evaluate. - /// Sequence to return in case the condition evaluates true. - /// Sequence to return in case the condition evaluates false. - /// Either of the two input sequences based on the result of evaluating the condition. - public static IQueryable If(this IQueryProvider provider, Expression> condition, IEnumerable thenSource, IEnumerable elseSource) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (condition == null) - throw new ArgumentNullException("condition"); - if (thenSource == null) - throw new ArgumentNullException("thenSource"); - if (elseSource == null) - throw new ArgumentNullException("elseSource"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - condition, - GetSourceExpression(thenSource), - GetSourceExpression(elseSource) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable If(Func condition, IEnumerable thenSource, IEnumerable elseSource) - { - return EnumerableEx.If(condition, thenSource, elseSource).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. - /// - /// Result sequence element type. - /// Query provider. - /// Condition to evaluate. - /// Sequence to return in case the condition evaluates true. - /// The given input sequence if the condition evaluates true; otherwise, an empty sequence. - public static IQueryable If(this IQueryProvider provider, Expression> condition, IEnumerable thenSource) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (condition == null) - throw new ArgumentNullException("condition"); - if (thenSource == null) - throw new ArgumentNullException("thenSource"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - condition, - GetSourceExpression(thenSource) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable If(Func condition, IEnumerable thenSource) - { - return EnumerableEx.If(condition, thenSource).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. - /// - /// Result sequence element type. - /// Source sequence to repeat while the condition evaluates true. - /// Loop condition. - /// Sequence generated by repeating the given sequence until the condition evaluates to false. - public static IQueryable DoWhile(this IQueryable source, Expression> condition) - { - if (source == null) - throw new ArgumentNullException("source"); - if (condition == null) - throw new ArgumentNullException("condition"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - source.Expression, - condition - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable DoWhile(IEnumerable source, Func condition) - { - return EnumerableEx.DoWhile(source, condition); - } -#pragma warning restore 1591 - - /// - /// Returns a sequence from a dictionary based on the result of evaluating a selector function. - /// - /// Type of the selector value. - /// Result sequence element type. - /// Query provider. - /// Selector function used to pick a sequence from the given sources. - /// Dictionary mapping selector values onto resulting sequences. - /// The source sequence corresponding with the evaluated selector value; otherwise, an empty sequence. - public static IQueryable Case(this IQueryProvider provider, Expression> selector, IDictionary> sources) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (selector == null) - throw new ArgumentNullException("selector"); - if (sources == null) - throw new ArgumentNullException("sources"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TValue), typeof(TResult)), - selector, - Expression.Constant(sources, typeof(IDictionary>)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Case(Func selector, IDictionary> sources) - { - return EnumerableEx.Case(selector, sources).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Returns a sequence from a dictionary based on the result of evaluating a selector function, also specifying a default sequence. - /// - /// Type of the selector value. - /// Result sequence element type. - /// Query provider. - /// Selector function used to pick a sequence from the given sources. - /// Dictionary mapping selector values onto resulting sequences. - /// Default sequence to return in case there's no corresponding source for the computed selector value. - /// The source sequence corresponding with the evaluated selector value; otherwise, the default source. - public static IQueryable Case(this IQueryProvider provider, Expression> selector, IDictionary> sources, IEnumerable defaultSource) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (selector == null) - throw new ArgumentNullException("selector"); - if (sources == null) - throw new ArgumentNullException("sources"); - if (defaultSource == null) - throw new ArgumentNullException("defaultSource"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TValue), typeof(TResult)), - selector, - Expression.Constant(sources, typeof(IDictionary>)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Case(Func selector, IDictionary> sources, IEnumerable defaultSource) - { - return EnumerableEx.Case(selector, sources, defaultSource).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence by enumerating a source sequence, mapping its elements on result sequences, and concatenating those sequences. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Query provider. - /// Source sequence. - /// Result selector to evaluate for each iteration over the source. - /// Sequence concatenating the inner sequences that result from evaluating the result selector on elements from the source. - public static IQueryable For(this IQueryProvider provider, IEnumerable source, Expression>> resultSelector) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (source == null) - throw new ArgumentNullException("source"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), - GetSourceExpression(source), - resultSelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable For(IEnumerable source, Func> resultSelector) - { - return EnumerableEx.For(source, resultSelector).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Concatenates the input sequences. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence with the elements of the source sequences concatenated. - public static IQueryable Concat(this IQueryable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - GetSourceExpression(sources) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Concat(IEnumerable> sources) - { - return EnumerableEx.Concat(sources); - } -#pragma warning restore 1591 - - /// - /// Concatenates the input sequences. - /// - /// Source sequence element type. - /// Query provider. - /// Source sequences. - /// Sequence with the elements of the source sequences concatenated. - public static IQueryable Concat(this IQueryProvider provider, params IEnumerable[] sources) - { - if (provider == null) - throw new ArgumentNullException("provider"); - if (sources == null) - throw new ArgumentNullException("sources"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - Expression.Constant(provider, typeof(IQueryProvider)), - GetSourceExpression(sources) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Concat(params IEnumerable[] sources) - { - return EnumerableEx.Concat(sources).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Projects each element of a sequence to an given sequence and flattens the resulting sequences into one sequence. - /// - /// First source sequence element type. - /// Second source sequence element type. - /// A sequence of values to project. - /// Inner sequence each source sequenec element is projected onto. - /// Sequence flattening the sequences that result from projecting elements in the source sequence. - public static IQueryable SelectMany(this IQueryable source, IEnumerable other) - { - if (source == null) - throw new ArgumentNullException("source"); - if (other == null) - throw new ArgumentNullException("other"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TOther)), - source.Expression, - GetSourceExpression(other) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable SelectMany(IEnumerable source, IEnumerable other) - { - return EnumerableEx.SelectMany(source, other); - } -#pragma warning restore 1591 - -#if NO_ZIP - /// - /// Merges two sequences by applying the specified selector function on index-based corresponding element pairs from both sequences. - /// - /// The type of the elements of the first input sequence. - /// The type of the elements of the second input sequence. - /// The type of the elements of the result sequence. - /// The first sequence to merge. - /// The second sequence to merge. - /// Function to apply to each pair of elements from both sequences. - /// Sequence consisting of the result of pairwise application of the selector function over pairs of elements from the source sequences. - public static IQueryable Zip(this IQueryable first, IEnumerable second, Expression> resultSelector) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return first.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TFirst), typeof(TSecond), typeof(TResult)), - first.Expression, - GetSourceExpression(second), - resultSelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Zip(IEnumerable first, IEnumerable second, Func resultSelector) - { - return EnumerableEx.Zip(first, second, resultSelector); - } -#pragma warning restore 1591 -#endif - - /// - /// Hides the enumerable sequence object identity. - /// - /// Source sequence element type. - /// Source sequence. - /// Enumerable sequence with the same behavior as the original, but hiding the source object identity. - /// AsQueryable doesn't hide the object identity, and simply acts as a cast to the IQueryable<TSource> interface. - public static IQueryable Hide(this IQueryable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Hide(IEnumerable source) - { - return EnumerableEx.Hide(source); - } -#pragma warning restore 1591 - - /// - /// Lazily invokes an action for each value in the sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IQueryable Do(this IQueryable source, Expression> onNext) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - onNext - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Do(IEnumerable source, Action onNext) - { - return EnumerableEx.Do(source, onNext); - } -#pragma warning restore 1591 - - /// - /// Lazily invokes an action for each value in the sequence, and executes an action for successful termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Action to invoke on successful termination of the sequence. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IQueryable Do(this IQueryable source, Expression> onNext, Expression onCompleted) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onCompleted == null) - throw new ArgumentNullException("onCompleted"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - onNext, - onCompleted - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Do(IEnumerable source, Action onNext, Action onCompleted) - { - return EnumerableEx.Do(source, onNext, onCompleted); - } -#pragma warning restore 1591 - - /// - /// Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Action to invoke on exceptional termination of the sequence. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IQueryable Do(this IQueryable source, Expression> onNext, Expression> onError) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onError == null) - throw new ArgumentNullException("onError"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - onNext, - onError - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Do(IEnumerable source, Action onNext, Action onError) - { - return EnumerableEx.Do(source, onNext, onError); - } -#pragma warning restore 1591 - - /// - /// Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Action to invoke on exceptional termination of the sequence. - /// Action to invoke on successful termination of the sequence. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IQueryable Do(this IQueryable source, Expression> onNext, Expression> onError, Expression onCompleted) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onError == null) - throw new ArgumentNullException("onError"); - if (onCompleted == null) - throw new ArgumentNullException("onCompleted"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - onNext, - onError, - onCompleted - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Do(IEnumerable source, Action onNext, Action onError, Action onCompleted) - { - return EnumerableEx.Do(source, onNext, onError, onCompleted); - } -#pragma warning restore 1591 - -#if !NO_RXINTERFACES - /// - /// Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Observer to invoke notification calls on. - /// Sequence exhibiting the side-effects of observer method invocation upon enumeration. - public static IQueryable Do(this IQueryable source, IObserver observer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (observer == null) - throw new ArgumentNullException("observer"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(observer, typeof(IObserver)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Do(IEnumerable source, IObserver observer) - { - return EnumerableEx.Do(source, observer); - } -#pragma warning restore 1591 -#endif - - /// - /// Generates a sequence of non-overlapping adjacent buffers over the source sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of elements for allocated buffers. - /// Sequence of buffers containing source sequence elements. - public static IQueryable> Buffer(this IQueryable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery>( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(count, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable> Buffer(IEnumerable source, int count) - { - return EnumerableEx.Buffer(source, count); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence of buffers over the source sequence, with specified length and possible overlap. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of elements for allocated buffers. - /// Number of elements to skip between the start of consecutive buffers. - /// Sequence of buffers containing source sequence elements. - public static IQueryable> Buffer(this IQueryable source, int count, int skip) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery>( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(count, typeof(int)), - Expression.Constant(skip, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable> Buffer(IEnumerable source, int count, int skip) - { - return EnumerableEx.Buffer(source, count, skip); - } -#pragma warning restore 1591 - - /// - /// Ignores all elements in the source sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Source sequence without its elements. - public static IQueryable IgnoreElements(this IQueryable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable IgnoreElements(IEnumerable source) - { - return EnumerableEx.IgnoreElements(source); - } -#pragma warning restore 1591 - - /// - /// Returns elements with a distinct key value by using the default equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Sequence that contains the elements from the source sequence with distinct key values. - public static IQueryable Distinct(this IQueryable source, Expression> keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Distinct(IEnumerable source, Func keySelector) - { - return EnumerableEx.Distinct(source, keySelector); - } -#pragma warning restore 1591 - - /// - /// Returns elements with a distinct key value by using the specified equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Comparer used to compare key values. - /// Sequence that contains the elements from the source sequence with distinct key values. - public static IQueryable Distinct(this IQueryable source, Expression> keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector, - Expression.Constant(comparer, typeof(IEqualityComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Distinct(IEnumerable source, Func keySelector, IEqualityComparer comparer) - { - return EnumerableEx.Distinct(source, keySelector, comparer); - } -#pragma warning restore 1591 - - /// - /// Returns consecutive distinct elements by using the default equality comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Sequence without adjacent non-distinct elements. - public static IQueryable DistinctUntilChanged(this IQueryable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable DistinctUntilChanged(IEnumerable source) - { - return EnumerableEx.DistinctUntilChanged(source); - } -#pragma warning restore 1591 - - /// - /// Returns consecutive distinct elements by using the specified equality comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Comparer used to compare values. - /// Sequence without adjacent non-distinct elements. - public static IQueryable DistinctUntilChanged(this IQueryable source, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(comparer, typeof(IEqualityComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable DistinctUntilChanged(IEnumerable source, IEqualityComparer comparer) - { - return EnumerableEx.DistinctUntilChanged(source, comparer); - } -#pragma warning restore 1591 - - /// - /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Sequence without adjacent non-distinct elements. - public static IQueryable DistinctUntilChanged(this IQueryable source, Expression> keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable DistinctUntilChanged(IEnumerable source, Func keySelector) - { - return EnumerableEx.DistinctUntilChanged(source, keySelector); - } -#pragma warning restore 1591 - - /// - /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Comparer used to compare key values. - /// Sequence without adjacent non-distinct elements. - public static IQueryable DistinctUntilChanged(this IQueryable source, Expression> keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TKey)), - source.Expression, - keySelector, - Expression.Constant(comparer, typeof(IEqualityComparer)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable DistinctUntilChanged(IEnumerable source, Func keySelector, IEqualityComparer comparer) - { - return EnumerableEx.DistinctUntilChanged(source, keySelector, comparer); - } -#pragma warning restore 1591 - - /// - /// Expands the sequence by recursively applying a selector function. - /// - /// Source sequence element type. - /// Source sequence. - /// Selector function to retrieve the next sequence to expand. - /// Sequence with results from the recursive expansion of the source sequence. - public static IQueryable Expand(this IQueryable source, Expression>> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - selector - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Expand(IEnumerable source, Func> selector) - { - return EnumerableEx.Expand(source, selector); - } -#pragma warning restore 1591 - - /// - /// Returns the source sequence prefixed with the specified value. - /// - /// Source sequence element type. - /// Source sequence. - /// Values to prefix the sequence with. - /// Sequence starting with the specified prefix value, followed by the source sequence. - public static IQueryable StartWith(this IQueryable source, params TSource[] values) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(values, typeof(TSource[])) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable StartWith(IEnumerable source, params TSource[] values) - { - return EnumerableEx.StartWith(source, values); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. - /// - /// Source sequence element type. - /// Accumulation type. - /// Source sequence. - /// Accumulator seed value. - /// Accumulation function to apply to the current accumulation value and each element of the sequence. - /// Sequence with all intermediate accumulation values resulting from scanning the sequence. - public static IQueryable Scan(this IQueryable source, TAccumulate seed, Expression> accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TAccumulate)), - source.Expression, - Expression.Constant(seed, typeof(TAccumulate)), - accumulator - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Scan(IEnumerable source, TAccumulate seed, Func accumulator) - { - return EnumerableEx.Scan(source, seed, accumulator); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. - /// - /// Source sequence element type. - /// Source sequence. - /// Accumulation function to apply to the current accumulation value and each element of the sequence. - /// Sequence with all intermediate accumulation values resulting from scanning the sequence. - public static IQueryable Scan(this IQueryable source, Expression> accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - accumulator - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Scan(IEnumerable source, Func accumulator) - { - return EnumerableEx.Scan(source, accumulator); - } -#pragma warning restore 1591 - - /// - /// Returns a specified number of contiguous elements from the end of the sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// The number of elements to take from the end of the sequence. - /// Sequence with the specified number of elements counting from the end of the source sequence. - public static IQueryable TakeLast(this IQueryable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(count, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable TakeLast(IEnumerable source, int count) - { - return EnumerableEx.TakeLast(source, count); - } -#pragma warning restore 1591 - - /// - /// Bypasses a specified number of contiguous elements from the end of the sequence and returns the remaining elements. - /// - /// Source sequence element type. - /// Source sequence. - /// The number of elements to skip from the end of the sequence before returning the remaining elements. - /// Sequence bypassing the specified number of elements counting from the end of the source sequence. - public static IQueryable SkipLast(this IQueryable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(count, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable SkipLast(IEnumerable source, int count) - { - return EnumerableEx.SkipLast(source, count); - } -#pragma warning restore 1591 - - /// - /// Repeats and concatenates the source sequence infinitely. - /// - /// Source sequence element type. - /// Source sequence. - /// Sequence obtained by concatenating the source sequence to itself infinitely. - public static IQueryable Repeat(this IQueryable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Repeat(IEnumerable source) - { - return EnumerableEx.Repeat(source); - } -#pragma warning restore 1591 - - /// - /// Repeats and concatenates the source sequence the given number of times. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of times to repeat the source sequence. - /// Sequence obtained by concatenating the source sequence to itself the specified number of times. - public static IQueryable Repeat(this IQueryable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), - source.Expression, - Expression.Constant(count, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static IEnumerable Repeat(IEnumerable source, int count) - { - return EnumerableEx.Repeat(source, count); - } -#pragma warning restore 1591 - - /// - /// Returns a sequence with no elements. - /// - /// Result sequence element type. - /// Query provider. - /// Sequence with no elements. - public static IQueryable Empty(this IQueryProvider provider) - { - if (provider == null) - throw new ArgumentNullException("provider"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Empty() - { - return Enumerable.Empty().AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence of integral numbers within a specified range. - /// - /// Query provider. - /// The value of the first integer in the sequence. - /// The number of sequential integers to generate. - /// Sequence that contains a range of sequential integral numbers. - public static IQueryable Range(this IQueryProvider provider, int start, int count) - { - if (provider == null) - throw new ArgumentNullException("provider"); - - return provider.CreateQuery( - Expression.Call( - null, - (MethodInfo)MethodInfo.GetCurrentMethod(), - Expression.Constant(provider, typeof(IQueryProvider)), - Expression.Constant(start, typeof(int)), - Expression.Constant(count, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Range(int start, int count) - { - return Enumerable.Range(start, count).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Generates a sequence that contains one repeated value. - /// - /// Result sequence element type. - /// Query provider. - /// The value to be repeated. - /// The number of times to repeat the value in the generated sequence. - /// Sequence that contains a repeated value. - public static IQueryable Repeat(this IQueryProvider provider, TResult element, int count) - { - if (provider == null) - throw new ArgumentNullException("provider"); - - return provider.CreateQuery( - Expression.Call( - null, - ((MethodInfo)MethodInfo.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)), - Expression.Constant(provider, typeof(IQueryProvider)), - Expression.Constant(element, typeof(TResult)), - Expression.Constant(count, typeof(int)) - ) - ); - } - -#pragma warning disable 1591 - [EditorBrowsable(EditorBrowsableState.Never)] - public static /*!*/IQueryable Repeat(TResult element, int count) - { - return EnumerableEx.Repeat(element, count).AsQueryable(); - } -#pragma warning restore 1591 - - /// - /// Gets the local Queryable provider. - /// - public static IQueryProvider Provider - { - get - { - return new QueryProviderShim(); - } - } - - class QueryProviderShim : IQueryProvider - { - public IQueryable CreateQuery(Expression expression) - { - var provider = new TElement[0].AsQueryable().Provider; - var res = Redir(expression); - return provider.CreateQuery(res); - } - - public IQueryable CreateQuery(Expression expression) - { - return CreateQuery(expression); - } - - public TResult Execute(Expression expression) - { - var provider = new TResult[0].AsQueryable().Provider; - var res = Redir(expression); - return provider.Execute(res); - } - - public object Execute(Expression expression) - { - return Execute(expression); - } - - private static Expression Redir(Expression expression) - { - var mce = expression as MethodCallExpression; - if (mce != null && mce.Method.DeclaringType == typeof(QueryableEx)) - { - if (mce.Arguments.Count >= 1 && typeof(IQueryProvider).IsAssignableFrom(mce.Arguments[0].Type)) - { - var ce = mce.Arguments[0] as ConstantExpression; - if (ce != null) - { - if (ce.Value is QueryProviderShim) - { - var targetType = typeof(QueryableEx); - var method = mce.Method; - var methods = GetMethods(targetType); - var arguments = mce.Arguments.Skip(1).ToList(); - - // - // From all the operators with the method's name, find the one that matches all arguments. - // - var typeArgs = method.IsGenericMethod ? method.GetGenericArguments() : null; - var targetMethod = methods[method.Name].FirstOrDefault(candidateMethod => ArgsMatch(candidateMethod, arguments, typeArgs)); - if (targetMethod == null) - throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "There is no method '{0}' on type '{1}' that matches the specified arguments", method.Name, targetType.Name)); - - // - // Restore generic arguments. - // - if (typeArgs != null) - targetMethod = targetMethod.MakeGenericMethod(typeArgs); - - // - // Finally, we need to deal with mismatches on Expression> versus Func<...>. - // - var parameters = targetMethod.GetParameters(); - for (int i = 0, n = parameters.Length; i < n; i++) - { - arguments[i] = Unquote(arguments[i]); - } - - // - // Emit a new call to the discovered target method. - // - return Expression.Call(null, targetMethod, arguments); - } - } - } - } - - return expression; - } - - private static ILookup GetMethods(Type type) - { - return type.GetMethods(BindingFlags.Static | BindingFlags.Public).ToLookup(m => m.Name); - } - - private static bool ArgsMatch(MethodInfo method, IList arguments, Type[] typeArgs) - { - // - // Number of parameters should match. Notice we've sanitized IQueryProvider "this" - // parameters first (see Redir). - // - var parameters = method.GetParameters(); - if (parameters.Length != arguments.Count) - return false; - - // - // Genericity should match too. - // - if (!method.IsGenericMethod && typeArgs != null && typeArgs.Length > 0) - return false; - - // - // Reconstruct the generic method if needed. - // - if (method.IsGenericMethodDefinition) - { - if (typeArgs == null) - return false; - - if (method.GetGenericArguments().Length != typeArgs.Length) - return false; - - var result = method.MakeGenericMethod(typeArgs); - parameters = result.GetParameters(); - } - - // - // Check compatibility for the parameter types. - // - for (int i = 0, n = arguments.Count; i < n; i++) - { - var parameterType = parameters[i].ParameterType; - var argument = arguments[i]; - - // - // For operators that take a function (like Where, Select), we'll be faced - // with a quoted argument and a discrepancy between Expression> - // and the underlying Func<...>. - // - if (!parameterType.IsAssignableFrom(argument.Type)) - { - argument = Unquote(argument); - if (!parameterType.IsAssignableFrom(argument.Type)) - return false; - } - } - - return true; - } - - private static Expression Unquote(Expression expression) - { - // - // Get rid of all outer quotes around an expression. - // - while (expression.NodeType == ExpressionType.Quote) - expression = ((UnaryExpression)expression).Operand; - - return expression; - } - } - - internal static Expression GetSourceExpression(IEnumerable source) - { - var q = source as IQueryable; - if (q != null) - return q.Expression; - - return Expression.Constant(source, typeof(IEnumerable)); - } - - internal static Expression GetSourceExpression(IEnumerable[] sources) - { - return Expression.NewArrayInit( - typeof(IEnumerable), - sources.Select(source => GetSourceExpression(source)) - ); - } - } -} diff --git a/Ix/System.Interactive.Providers/System.Interactive.Providers.csproj b/Ix/System.Interactive.Providers/System.Interactive.Providers.csproj deleted file mode 100644 index 839f290..0000000 --- a/Ix/System.Interactive.Providers/System.Interactive.Providers.csproj +++ /dev/null @@ -1,41 +0,0 @@ - - - - Debug - AnyCPU - 8.0.30703 - 2.0 - {6D62E966-469D-4A99-BD43-0A17FA14FB4F} - Library - Properties - System.Interactive.Providers - System.Interactive.Providers - v4.0 - 512 - true - - - - $(OutputPath)\$(AssemblyName).XML - - - Profile1 - - - - - - - - - - - - - - {8E4B04F0-915E-48F9-9796-76278C6094BD} - System.Interactive - - - - \ No newline at end of file diff --git a/Ix/System.Interactive/EnumerableEx.Aggregates.cs b/Ix/System.Interactive/EnumerableEx.Aggregates.cs deleted file mode 100644 index 204d5ee..0000000 --- a/Ix/System.Interactive/EnumerableEx.Aggregates.cs +++ /dev/null @@ -1,173 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; - -namespace System.Linq -{ - /// - /// Provides a set of additional static methods that allow querying enumerable sequences. - /// - public static partial class EnumerableEx - { - /// - /// Determines whether an enumerable sequence is empty. - /// - /// Source sequence element type. - /// Source sequence. - /// true if the sequence is empty; false otherwise. - public static bool IsEmpty(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return !source.Any(); - } - - /// - /// Returns the minimum value in the enumerable sequence by using the specified comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Comparer used to determine the minimum value. - /// Minimum value in the sequence. - public static TSource Min(this IEnumerable source, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return MinBy(source, x => x, comparer).First(); - } - - /// - /// Returns the elements with the minimum key value by using the default comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// List with the elements that share the same minimum key value. - public static IList MinBy(this IEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return MinBy(source, keySelector, Comparer.Default); - } - - /// - /// Returns the elements with the minimum key value by using the specified comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// Comparer used to determine the minimum key value. - /// List with the elements that share the same minimum key value. - public static IList MinBy(this IEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ExtremaBy(source, keySelector, (key, minValue) => -comparer.Compare(key, minValue)); - } - - /// - /// Returns the maximum value in the enumerable sequence by using the specified comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Comparer used to determine the maximum value. - /// Maximum value in the sequence. - public static TSource Max(this IEnumerable source, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return MaxBy(source, x => x, comparer).First(); - } - - /// - /// Returns the elements with the maximum key value by using the default comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// List with the elements that share the same maximum key value. - public static IList MaxBy(this IEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return MaxBy(source, keySelector, Comparer.Default); - } - - /// - /// Returns the elements with the minimum key value by using the specified comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector used to extract the key for each element in the sequence. - /// Comparer used to determine the maximum key value. - /// List with the elements that share the same maximum key value. - public static IList MaxBy(this IEnumerable source, Func keySelector, IComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return ExtremaBy(source, keySelector, (key, minValue) => comparer.Compare(key, minValue)); - } - - private static IList ExtremaBy(IEnumerable source, Func keySelector, Func compare) - { - var result = new List(); - - using (var e = source.GetEnumerator()) - { - if (!e.MoveNext()) - throw new InvalidOperationException("Source sequence doesn't contain any elements."); - - var current = e.Current; - var resKey = keySelector(current); - result.Add(current); - - while (e.MoveNext()) - { - var cur = e.Current; - var key = keySelector(cur); - - var cmp = compare(key, resKey); - if (cmp == 0) - { - result.Add(cur); - } - else if (cmp > 0) - { - result = new List { cur }; - resKey = key; - } - } - } - - return result; - } - } -} diff --git a/Ix/System.Interactive/EnumerableEx.Buffering.cs b/Ix/System.Interactive/EnumerableEx.Buffering.cs deleted file mode 100644 index 35785bf..0000000 --- a/Ix/System.Interactive/EnumerableEx.Buffering.cs +++ /dev/null @@ -1,647 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Diagnostics; - -namespace System.Linq -{ - public static partial class EnumerableEx - { - /// - /// Creates a buffer with a shared view over the source sequence, causing each enumerator to fetch the next element from the source sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Buffer enabling each enumerator to retrieve elements from the shared source sequence. - /// - /// var rng = Enumerable.Range(0, 10).Share(); - /// - /// var e1 = rng.GetEnumerator(); // Both e1 and e2 will consume elements from - /// var e2 = rng.GetEnumerator(); // the source sequence. - /// - /// Assert.IsTrue(e1.MoveNext()); - /// Assert.AreEqual(0, e1.Current); - /// - /// Assert.IsTrue(e1.MoveNext()); - /// Assert.AreEqual(1, e1.Current); - /// - /// Assert.IsTrue(e2.MoveNext()); // e2 "steals" element 2 - /// Assert.AreEqual(2, e2.Current); - /// - /// Assert.IsTrue(e1.MoveNext()); // e1 can't see element 2 - /// Assert.AreEqual(3, e1.Current); - /// - public static IBuffer Share(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return new SharedBuffer(source.GetEnumerator()); - } - - /// - /// Shares the source sequence within a selector function where each enumerator can fetch the next element from the source sequence. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Selector function with shared access to the source sequence for each enumerator. - /// Sequence resulting from applying the selector function to the shared view over the source sequence. - public static IEnumerable Share(this IEnumerable source, Func, IEnumerable> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => selector(source.Share()).GetEnumerator()); - } - - class SharedBuffer : IBuffer - { - private IEnumerator _source; - private bool _disposed; - - public SharedBuffer(IEnumerator source) - { - _source = source; - } - - public IEnumerator GetEnumerator() - { - if (_disposed) - throw new ObjectDisposedException(""); - - return GetEnumerator_(); - } - - private IEnumerator GetEnumerator_() - { - while (true) - { - if (_disposed) - throw new ObjectDisposedException(""); - - var hasValue = default(bool); - var current = default(T); - - lock (_source) - { - hasValue = _source.MoveNext(); - if (hasValue) - current = _source.Current; - } - - if (hasValue) - yield return current; - else - break; - } - } - - System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { - if (_disposed) - throw new ObjectDisposedException(""); - - return GetEnumerator(); - } - - public void Dispose() - { - lock (_source) - { - if (!_disposed) - { - _source.Dispose(); - _source = null; - } - - _disposed = true; - } - } - } - - /// - /// Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of the sequence from the current index in the buffer. - /// - /// Source sequence element type. - /// Source sequence. - /// Buffer enabling each enumerator to retrieve elements from the shared source sequence, starting from the index at the point of obtaining the enumerator. - /// - /// var rng = Enumerable.Range(0, 10).Publish(); - /// - /// var e1 = rng.GetEnumerator(); // e1 has a view on the source starting from element 0 - /// - /// Assert.IsTrue(e1.MoveNext()); - /// Assert.AreEqual(0, e1.Current); - /// - /// Assert.IsTrue(e1.MoveNext()); - /// Assert.AreEqual(1, e1.Current); - /// - /// var e2 = rng.GetEnumerator(); - /// - /// Assert.IsTrue(e2.MoveNext()); // e2 has a view on the source starting from element 2 - /// Assert.AreEqual(2, e2.Current); - /// - /// Assert.IsTrue(e1.MoveNext()); // e1 continues to enumerate over its view - /// Assert.AreEqual(2, e1.Current); - /// - public static IBuffer Publish(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return new PublishedBuffer(source.GetEnumerator()); - } - - /// - /// Publishes the source sequence within a selector function where each enumerator can obtain a view over a tail of the source sequence. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Selector function with published access to the source sequence for each enumerator. - /// Sequence resulting from applying the selector function to the published view over the source sequence. - public static IEnumerable Publish(this IEnumerable source, Func, IEnumerable> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => selector(source.Publish()).GetEnumerator()); - } - - class PublishedBuffer : IBuffer - { - private IEnumerator _source; - private RefCountList _buffer; - private bool _stopped; - private Exception _error; - private bool _disposed; - - public PublishedBuffer(IEnumerator source) - { - _buffer = new RefCountList(0); - _source = source; - } - - public IEnumerator GetEnumerator() - { - if (_disposed) - throw new ObjectDisposedException(""); - - var i = default(int); - lock (_source) - { - i = _buffer.Count; - _buffer.ReaderCount++; - } - - return GetEnumerator_(i); - } - - private IEnumerator GetEnumerator_(int i) - { - try - { - while (true) - { - if (_disposed) - throw new ObjectDisposedException(""); - - var hasValue = default(bool); - var current = default(T); - - lock (_source) - { - if (i >= _buffer.Count) - { - if (!_stopped) - { - try - { - hasValue = _source.MoveNext(); - if (hasValue) - current = _source.Current; - } - catch (Exception ex) - { - _stopped = true; - _error = ex; - - _source.Dispose(); - } - } - - if (_stopped) - { - if (_error != null) - throw _error; - else - break; - } - - if (hasValue) - { - _buffer.Add(current); - } - } - else - { - hasValue = true; - } - } - - if (hasValue) - yield return _buffer[i]; - else - break; - - i++; - } - } - finally - { - if (_buffer != null) - _buffer.Done(i + 1); - } - } - - System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { - if (_disposed) - throw new ObjectDisposedException(""); - - return GetEnumerator(); - } - - public void Dispose() - { - lock (_source) - { - if (!_disposed) - { - _source.Dispose(); - _source = null; - - _buffer.Clear(); - _buffer = null; - } - - _disposed = true; - } - } - } - - /// - /// Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to all of the sequence's elements without causing multiple enumerations over the source. - /// - /// Source sequence element type. - /// Source sequence. - /// Buffer enabling each enumerator to retrieve all elements from the shared source sequence, without duplicating source enumeration side-effects. - /// - /// var rng = Enumerable.Range(0, 10).Do(x => Console.WriteLine(x)).Memoize(); - /// - /// var e1 = rng.GetEnumerator(); - /// - /// Assert.IsTrue(e1.MoveNext()); // Prints 0 - /// Assert.AreEqual(0, e1.Current); - /// - /// Assert.IsTrue(e1.MoveNext()); // Prints 1 - /// Assert.AreEqual(1, e1.Current); - /// - /// var e2 = rng.GetEnumerator(); - /// - /// Assert.IsTrue(e2.MoveNext()); // Doesn't print anything; the side-effect of Do - /// Assert.AreEqual(0, e2.Current); // has already taken place during e1's iteration. - /// - /// Assert.IsTrue(e1.MoveNext()); // Prints 2 - /// Assert.AreEqual(2, e1.Current); - /// - public static IBuffer Memoize(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return new MemoizedBuffer(source.GetEnumerator()); - } - - /// - /// Memoizes the source sequence within a selector function where each enumerator can get access to all of the sequence's elements without causing multiple enumerations over the source. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Selector function with memoized access to the source sequence for each enumerator. - /// Sequence resulting from applying the selector function to the memoized view over the source sequence. - public static IEnumerable Memoize(this IEnumerable source, Func, IEnumerable> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => selector(source.Memoize()).GetEnumerator()); - } - - /// - /// Creates a buffer with a view over the source sequence, causing a specified number of enumerators to obtain access to all of the sequence's elements without causing multiple enumerations over the source. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of enumerators that can access the underlying buffer. Once every enumerator has obtained an element from the buffer, the element is removed from the buffer. - /// Buffer enabling a specified number of enumerators to retrieve all elements from the shared source sequence, without duplicating source enumeration side-effects. - public static IBuffer Memoize(this IEnumerable source, int readerCount) - { - if (source == null) - throw new ArgumentNullException("source"); - if (readerCount <= 0) - throw new ArgumentOutOfRangeException("readerCount"); - - return new MemoizedBuffer(source.GetEnumerator(), readerCount); - } - - /// - /// Memoizes the source sequence within a selector function where a specified number of enumerators can get access to all of the sequence's elements without causing multiple enumerations over the source. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Number of enumerators that can access the underlying buffer. Once every enumerator has obtained an element from the buffer, the element is removed from the buffer. - /// Selector function with memoized access to the source sequence for a specified number of enumerators. - /// Sequence resulting from applying the selector function to the memoized view over the source sequence. - public static IEnumerable Memoize(this IEnumerable source, int readerCount, Func, IEnumerable> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (readerCount <= 0) - throw new ArgumentOutOfRangeException("readerCount"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return Create(() => selector(source.Memoize(readerCount)).GetEnumerator()); - } - - class MemoizedBuffer : IBuffer - { - private IEnumerator _source; - private IRefCountList _buffer; - private bool _stopped; - private Exception _error; - private bool _disposed; - - public MemoizedBuffer(IEnumerator source) - : this(source, new MaxRefCountList()) - { - } - - public MemoizedBuffer(IEnumerator source, int readerCount) - : this(source, new RefCountList(readerCount)) - { - } - - private MemoizedBuffer(IEnumerator source, IRefCountList buffer) - { - _source = source; - _buffer = buffer; - } - - public IEnumerator GetEnumerator() - { - if (_disposed) - throw new ObjectDisposedException(""); - - return GetEnumerator_(); - } - - private IEnumerator GetEnumerator_() - { - var i = 0; - - try - { - while (true) - { - if (_disposed) - throw new ObjectDisposedException(""); - - var hasValue = default(bool); - var current = default(T); - - lock (_source) - { - if (i >= _buffer.Count) - { - if (!_stopped) - { - try - { - hasValue = _source.MoveNext(); - if (hasValue) - current = _source.Current; - } - catch (Exception ex) - { - _stopped = true; - _error = ex; - - _source.Dispose(); - } - } - - if (_stopped) - { - if (_error != null) - throw _error; - else - break; - } - - if (hasValue) - { - _buffer.Add(current); - } - } - else - { - hasValue = true; - } - } - - if (hasValue) - yield return _buffer[i]; - else - break; - - i++; - } - } - finally - { - if (_buffer != null) - _buffer.Done(i + 1); - } - } - - System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { - if (_disposed) - throw new ObjectDisposedException(""); - - return GetEnumerator(); - } - - public void Dispose() - { - lock (_source) - { - if (!_disposed) - { - _source.Dispose(); - _source = null; - - _buffer.Clear(); - _buffer = null; - } - - _disposed = true; - } - } - } - } - - /// - /// Represents a buffer exposing a shared view over an underlying enumerable sequence. - /// - /// Element type. - public interface IBuffer< -#if !NO_VARIANCE && !SILVERLIGHT4 // SL4 has defined IEnumerable with invariant T - out -#endif - T> : IEnumerable, IDisposable - { - } - - interface IRefCountList - { - void Clear(); - - int Count { get; } - - T this[int i] - { - get; - } - - void Add(T item); - - void Done(int index); - } - - class MaxRefCountList : IRefCountList - { - private IList _list = new List(); - - public void Clear() - { - _list.Clear(); - } - - public int Count - { - get { return _list.Count; } - } - - public T this[int i] - { - get { return _list[i]; } - } - - public void Add(T item) - { - _list.Add(item); - } - - public void Done(int index) - { - } - } - - class RefCountList : IRefCountList - { - private int _readerCount; - private readonly IDictionary _list; - private int _count; - - public RefCountList(int readerCount) - { - _readerCount = readerCount; - _list = new Dictionary(); - } - - public int ReaderCount - { - get - { - return _readerCount; - } - - set - { - _readerCount = value; - } - } - - public void Clear() - { - _list.Clear(); - } - - public int Count - { - get { return _count; } - } - - public T this[int i] - { - get - { - Debug.Assert(i < _count); - - var res = default(RefCount); - if (!_list.TryGetValue(i, out res)) - throw new InvalidOperationException("Element no longer available in the buffer."); - - var val = res.Value; - if (--res.Count == 0) - _list.Remove(i); - - return val; - } - } - - public void Add(T item) - { - _list[_count] = new RefCount { Value = item, Count = _readerCount }; - _count++; - } - - public void Done(int index) - { - for (int i = index; i < _count; i++) - { - var ignore = this[i]; - } - - _readerCount--; - } - - class RefCount - { - public int Count; - public T Value; - } - } -} diff --git a/Ix/System.Interactive/EnumerableEx.Creation.cs b/Ix/System.Interactive/EnumerableEx.Creation.cs deleted file mode 100644 index 2ba4f16..0000000 --- a/Ix/System.Interactive/EnumerableEx.Creation.cs +++ /dev/null @@ -1,173 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; - -namespace System.Linq -{ - public static partial class EnumerableEx - { - /// - /// Creates an enumerable sequence based on an enumerator factory function. - /// - /// Result sequence element type. - /// Enumerator factory function. - /// Sequence that will invoke the enumerator factory upon a call to GetEnumerator. - public static IEnumerable Create(Func> getEnumerator) - { - if (getEnumerator == null) - throw new ArgumentNullException("getEnumerator"); - - return new AnonymousEnumerable(getEnumerator); - } - - class AnonymousEnumerable : IEnumerable - { - private readonly Func> _getEnumerator; - - public AnonymousEnumerable(Func> getEnumerator) - { - _getEnumerator = getEnumerator; - } - - public IEnumerator GetEnumerator() - { - return _getEnumerator(); - } - - Collections.IEnumerator Collections.IEnumerable.GetEnumerator() - { - return GetEnumerator(); - } - } - - /// - /// Returns a sequence with a single element. - /// - /// Result sequence element type. - /// Single element of the resulting sequence. - /// Sequence with a single element. - public static IEnumerable Return(TResult value) - { - yield return value; - } - - /// - /// Returns a sequence that throws an exception upon enumeration. - /// - /// Result sequence element type. - /// Exception to throw upon enumerating the resulting sequence. - /// Sequence that throws the specified exception upon enumeration. - public static IEnumerable Throw(Exception exception) - { - if (exception == null) - throw new ArgumentNullException("exception"); - - return Throw_(exception); - } - - private static IEnumerable Throw_(Exception exception) - { - throw exception; -#pragma warning disable 0162 - yield break; -#pragma warning restore 0162 - } - - /// - /// Creates an enumerable sequence based on an enumerable factory function. - /// - /// Result sequence element type. - /// Enumerable factory function. - /// Sequence that will invoke the enumerable factory upon a call to GetEnumerator. - public static IEnumerable Defer(Func> enumerableFactory) - { - if (enumerableFactory == null) - throw new ArgumentNullException("enumerableFactory"); - - return Defer_(enumerableFactory); - } - - private static IEnumerable Defer_(Func> enumerableFactory) - { - foreach (var item in enumerableFactory()) - yield return item; - } - - /// - /// Generates a sequence by mimicking a for loop. - /// - /// State type. - /// Result sequence element type. - /// Initial state of the generator loop. - /// Loop condition. - /// State update function to run after every iteration of the generator loop. - /// Result selector to compute resulting sequence elements. - /// Sequence obtained by running the generator loop, yielding computed elements. - public static IEnumerable Generate(TState initialState, Func condition, Func iterate, Func resultSelector) - { - if (condition == null) - throw new ArgumentNullException("condition"); - if (iterate == null) - throw new ArgumentNullException("iterate"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return Generate_(initialState, condition, iterate, resultSelector); - } - - private static IEnumerable Generate_(TState initialState, Func condition, Func iterate, Func resultSelector) - { - for (var i = initialState; condition(i); i = iterate(i)) - yield return resultSelector(i); - } - - /// - /// Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage duration. - /// - /// Source element type. - /// Resource type. - /// Resource factory function. - /// Enumerable factory function, having access to the obtained resource. - /// Sequence whose use controls the lifetime of the associated obtained resource. - public static IEnumerable Using(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable - { - if (resourceFactory == null) - throw new ArgumentNullException("resourceFactory"); - if (enumerableFactory == null) - throw new ArgumentNullException("enumerableFactory"); - - return Using_(resourceFactory, enumerableFactory); - } - - private static IEnumerable Using_(Func resourceFactory, Func> enumerableFactory) where TResource : IDisposable - { - using (var res = resourceFactory()) - foreach (var item in enumerableFactory(res)) - yield return item; - } - - /// - /// Generates a sequence by repeating the given value infinitely. - /// - /// Result sequence element type. - /// Value to repreat in the resulting sequence. - /// Sequence repeating the given value infinitely. - public static IEnumerable Repeat(TResult value) - { - while (true) - yield return value; - } - - /// - /// Generates a sequence that contains one repeated value. - /// - /// Result sequence element type. - /// The value to be repeated. - /// The number of times to repeat the value in the generated sequence. - /// Sequence that contains a repeated value. - public static IEnumerable Repeat(TResult element, int count) - { - return Enumerable.Repeat(element, count); - } - } -} diff --git a/Ix/System.Interactive/EnumerableEx.Exceptions.cs b/Ix/System.Interactive/EnumerableEx.Exceptions.cs deleted file mode 100644 index a3ff330..0000000 --- a/Ix/System.Interactive/EnumerableEx.Exceptions.cs +++ /dev/null @@ -1,284 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; - -namespace System.Linq -{ - public static partial class EnumerableEx - { - /// - /// Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error. - /// - /// Source sequence element type. - /// Exception type to catch. - /// Source sequence. - /// Handler to invoke when an exception of the specified type occurs. - /// Source sequence, concatenated with an exception handler result sequence in case of an error. - public static IEnumerable Catch(this IEnumerable source, Func> handler) - where TException : Exception - { - if (source == null) - throw new ArgumentNullException("source"); - if (handler == null) - throw new ArgumentNullException("handler"); - - return source.Catch_(handler); - } - - private static IEnumerable Catch_(this IEnumerable source, Func> handler) - where TException : Exception - { - var err = default(IEnumerable); - - using (var e = source.GetEnumerator()) - { - while (true) - { - var b = default(bool); - var c = default(TSource); - - try - { - b = e.MoveNext(); - c = e.Current; - } - catch (TException ex) - { - err = handler(ex); - break; - } - - if (!b) - break; - - yield return c; - } - } - - if (err != null) - { - foreach (var item in err) - yield return item; - } - } - - /// - /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence that continues to concatenate source sequences while errors occur. - public static IEnumerable Catch(this IEnumerable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Catch_(); - } - - /// - /// Creates a sequence by concatenating source sequences until a source sequence completes successfully. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence that continues to concatenate source sequences while errors occur. - public static IEnumerable Catch(params IEnumerable[] sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Catch_(); - } - - /// - /// Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error. - /// - /// Source sequence element type. - /// First sequence. - /// Second sequence, concatenated to the result in case the first sequence completes exceptionally. - /// The first sequence, followed by the second sequence in case an error is produced. - public static IEnumerable Catch(this IEnumerable first, IEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return new[] { first, second }.Catch_(); - } - - private static IEnumerable Catch_(this IEnumerable> sources) - { - var error = default(Exception); - - foreach (var source in sources) - { - using (var e = source.GetEnumerator()) - { - error = null; - - while (true) - { - var b = default(bool); - var c = default(TSource); - - try - { - b = e.MoveNext(); - c = e.Current; - } - catch (Exception ex) - { - error = ex; - break; - } - - if (!b) - break; - - yield return c; - } - - if (error == null) - break; - } - } - - if (error != null) - throw error; - } - - /// - /// Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to run upon termination of the sequence, or when an enumerator is disposed. - /// Source sequence with guarantees on the invocation of the finally action. - public static IEnumerable Finally(this IEnumerable source, Action finallyAction) - { - if (source == null) - throw new ArgumentNullException("source"); - if (finallyAction == null) - throw new ArgumentNullException("finallyAction"); - - return source.Finally_(finallyAction); - } - - private static IEnumerable Finally_(this IEnumerable source, Action finallyAction) - { - try - { - foreach (var item in source) - yield return item; - } - finally - { - finallyAction(); - } - } - - /// - /// Creates a sequence that concatenates both given sequences, regardless of whether an error occurs. - /// - /// Source sequence element type. - /// First sequence. - /// Second sequence. - /// Sequence concatenating the elements of both sequences, ignoring errors. - public static IEnumerable OnErrorResumeNext(this IEnumerable first, IEnumerable second) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - - return OnErrorResumeNext_(new[] { first, second }); - } - - /// - /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence concatenating the elements of the given sequences, ignoring errors. - public static IEnumerable OnErrorResumeNext(params IEnumerable[] sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return OnErrorResumeNext_(sources); - } - - /// - /// Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence concatenating the elements of the given sequences, ignoring errors. - public static IEnumerable OnErrorResumeNext(this IEnumerable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return OnErrorResumeNext_(sources); - } - - private static IEnumerable OnErrorResumeNext_(IEnumerable> sources) - { - foreach (var source in sources) - { - using (var innerEnumerator = source.GetEnumerator()) - { - while (true) - { - var value = default(TSource); - try - { - if (!innerEnumerator.MoveNext()) - break; - value = innerEnumerator.Current; - } - catch - { - break; - } - - yield return value; - } - } - } - } - - /// - /// Creates a sequence that retries enumerating the source sequence as long as an error occurs. - /// - /// Source sequence element type. - /// Source sequence. - /// Sequence concatenating the results of the source sequence as long as an error occurs. - public static IEnumerable Retry(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return new[] { source }.Repeat().Catch(); - } - - /// - /// Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified maximum number of retries. - /// - /// Source sequence element type. - /// Source sequence. - /// Maximum number of retries. - /// Sequence concatenating the results of the source sequence as long as an error occurs. - public static IEnumerable Retry(this IEnumerable source, int retryCount) - { - if (source == null) - throw new ArgumentNullException("source"); - if (retryCount < 0) - throw new ArgumentOutOfRangeException("retryCount"); - - return new[] { source }.Repeat(retryCount).Catch(); - } - } -} diff --git a/Ix/System.Interactive/EnumerableEx.Imperative.cs b/Ix/System.Interactive/EnumerableEx.Imperative.cs deleted file mode 100644 index fff3927..0000000 --- a/Ix/System.Interactive/EnumerableEx.Imperative.cs +++ /dev/null @@ -1,156 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; - -namespace System.Linq -{ - public static partial class EnumerableEx - { - /// - /// Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. - /// - /// Result sequence element type. - /// Loop condition. - /// Sequence to repeat while the condition evaluates true. - /// Sequence generated by repeating the given sequence while the condition evaluates to true. - public static IEnumerable While(Func condition, IEnumerable source) - { - if (condition == null) - throw new ArgumentNullException("condition"); - if (source == null) - throw new ArgumentNullException("source"); - - return WhileCore(condition, source).Concat(); - } - - static IEnumerable> WhileCore(Func condition, IEnumerable source) - { - while (condition()) - yield return source; - } - - /// - /// Returns an enumerable sequence based on the evaluation result of the given condition. - /// - /// Result sequence element type. - /// Condition to evaluate. - /// Sequence to return in case the condition evaluates true. - /// Sequence to return in case the condition evaluates false. - /// Either of the two input sequences based on the result of evaluating the condition. - public static IEnumerable If(Func condition, IEnumerable thenSource, IEnumerable elseSource) - { - if (condition == null) - throw new ArgumentNullException("condition"); - if (thenSource == null) - throw new ArgumentNullException("thenSource"); - if (elseSource == null) - throw new ArgumentNullException("elseSource"); - - return EnumerableEx.Defer(() => condition() ? thenSource : elseSource); - } - - /// - /// Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. - /// - /// Result sequence element type. - /// Condition to evaluate. - /// Sequence to return in case the condition evaluates true. - /// The given input sequence if the condition evaluates true; otherwise, an empty sequence. - public static IEnumerable If(Func condition, IEnumerable thenSource) - { - if (condition == null) - throw new ArgumentNullException("condition"); - if (thenSource == null) - throw new ArgumentNullException("thenSource"); - - return EnumerableEx.Defer(() => condition() ? thenSource : Enumerable.Empty()); - } - - /// - /// Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. - /// - /// Result sequence element type. - /// Source sequence to repeat while the condition evaluates true. - /// Loop condition. - /// Sequence generated by repeating the given sequence until the condition evaluates to false. - public static IEnumerable DoWhile(this IEnumerable source, Func condition) - { - if (source == null) - throw new ArgumentNullException("source"); - if (condition == null) - throw new ArgumentNullException("condition"); - - return source.Concat(While(condition, source)); - } - - /// - /// Returns a sequence from a dictionary based on the result of evaluating a selector function. - /// - /// Type of the selector value. - /// Result sequence element type. - /// Selector function used to pick a sequence from the given sources. - /// Dictionary mapping selector values onto resulting sequences. - /// The source sequence corresponding with the evaluated selector value; otherwise, an empty sequence. - public static IEnumerable Case(Func selector, IDictionary> sources) - { - if (selector == null) - throw new ArgumentNullException("selector"); - if (sources == null) - throw new ArgumentNullException("sources"); - - return Case(selector, sources, Enumerable.Empty()); - } - - /// - /// Returns a sequence from a dictionary based on the result of evaluating a selector function, also specifying a default sequence. - /// - /// Type of the selector value. - /// Result sequence element type. - /// Selector function used to pick a sequence from the given sources. - /// Dictionary mapping selector values onto resulting sequences. - /// Default sequence to return in case there's no corresponding source for the computed selector value. - /// The source sequence corresponding with the evaluated selector value; otherwise, the default source. - public static IEnumerable Case(Func selector, IDictionary> sources, IEnumerable defaultSource) - { - if (selector == null) - throw new ArgumentNullException("selector"); - if (sources == null) - throw new ArgumentNullException("sources"); - if (defaultSource == null) - throw new ArgumentNullException("defaultSource"); - - return EnumerableEx.Defer(() => - { - IEnumerable result; - if (!sources.TryGetValue(selector(), out result)) - result = defaultSource; - return result; - }); - } - - /// - /// Generates a sequence by enumerating a source sequence, mapping its elements on result sequences, and concatenating those sequences. - /// - /// Source sequence element type. - /// Result sequence element type. - /// Source sequence. - /// Result selector to evaluate for each iteration over the source. - /// Sequence concatenating the inner sequences that result from evaluating the result selector on elements from the source. - public static IEnumerable For(IEnumerable source, Func> resultSelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return ForCore(source, resultSelector).Concat(); - } - - static IEnumerable> ForCore(IEnumerable source, Func> resultSelector) - { - return source.Select(resultSelector); - } - } -} diff --git a/Ix/System.Interactive/EnumerableEx.Multiple.cs b/Ix/System.Interactive/EnumerableEx.Multiple.cs deleted file mode 100644 index ffba503..0000000 --- a/Ix/System.Interactive/EnumerableEx.Multiple.cs +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; - -namespace System.Linq -{ - public static partial class EnumerableEx - { - /// - /// Concatenates the input sequences. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence with the elements of the source sequences concatenated. - public static IEnumerable Concat(this IEnumerable> sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Concat_(); - } - - /// - /// Concatenates the input sequences. - /// - /// Source sequence element type. - /// Source sequences. - /// Sequence with the elements of the source sequences concatenated. - public static IEnumerable Concat(params IEnumerable[] sources) - { - if (sources == null) - throw new ArgumentNullException("sources"); - - return sources.Concat_(); - } - - private static IEnumerable Concat_(this IEnumerable> sources) - { - foreach (var source in sources) - foreach (var item in source) - yield return item; - } - - /// - /// Projects each element of a sequence to an given sequence and flattens the resulting sequences into one sequence. - /// - /// First source sequence element type. - /// Second source sequence element type. - /// A sequence of values to project. - /// Inner sequence each source sequenec element is projected onto. - /// Sequence flattening the sequences that result from projecting elements in the source sequence. - public static IEnumerable SelectMany(this IEnumerable source, IEnumerable other) - { - if (source == null) - throw new ArgumentNullException("source"); - if (other == null) - throw new ArgumentNullException("other"); - - return source.SelectMany(_ => other); - } - -#if NO_ZIP - /// - /// Merges two sequences by applying the specified selector function on index-based corresponding element pairs from both sequences. - /// - /// The type of the elements of the first input sequence. - /// The type of the elements of the second input sequence. - /// The type of the elements of the result sequence. - /// The first sequence to merge. - /// The second sequence to merge. - /// Function to apply to each pair of elements from both sequences. - /// Sequence consisting of the result of pairwise application of the selector function over pairs of elements from the source sequences. - public static IEnumerable Zip(this IEnumerable first, IEnumerable second, Func resultSelector) - { - if (first == null) - throw new ArgumentNullException("first"); - if (second == null) - throw new ArgumentNullException("second"); - if (resultSelector == null) - throw new ArgumentNullException("resultSelector"); - - return Zip_(first, second, resultSelector); - } - - private static IEnumerable Zip_(this IEnumerable first, IEnumerable second, Func resultSelector) - { - using (var e1 = first.GetEnumerator()) - using (var e2 = second.GetEnumerator()) - while (e1.MoveNext() && e2.MoveNext()) - yield return resultSelector(e1.Current, e2.Current); - } -#endif - } -} diff --git a/Ix/System.Interactive/EnumerableEx.Single.cs b/Ix/System.Interactive/EnumerableEx.Single.cs deleted file mode 100644 index 6151ea9..0000000 --- a/Ix/System.Interactive/EnumerableEx.Single.cs +++ /dev/null @@ -1,672 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; - -namespace System.Linq -{ - public static partial class EnumerableEx - { - /// - /// Hides the enumerable sequence object identity. - /// - /// Source sequence element type. - /// Source sequence. - /// Enumerable sequence with the same behavior as the original, but hiding the source object identity. - /// AsEnumerable doesn't hide the object identity, and simply acts as a cast to the IEnumerable<TSource> interface. - public static IEnumerable Hide(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.Hide_(); - } - - private static IEnumerable Hide_(this IEnumerable source) - { - foreach (var item in source) - yield return item; - } - - /// - /// Enumerates the sequence and invokes the given action for each value in the sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - public static void ForEach(this IEnumerable source, Action onNext) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - - foreach (var item in source) - onNext(item); - } - - /// - /// Enumerates the sequence and invokes the given action for each value in the sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - public static void ForEach(this IEnumerable source, Action onNext) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - - var i = 0; - foreach (var item in source) - onNext(item, i++); - } - - /// - /// Lazily invokes an action for each value in the sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IEnumerable Do(this IEnumerable source, Action onNext) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - - return DoHelper(source, onNext, _ => { }, () => { }); - } - - /// - /// Lazily invokes an action for each value in the sequence, and executes an action for successful termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Action to invoke on successful termination of the sequence. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IEnumerable Do(this IEnumerable source, Action onNext, Action onCompleted) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onCompleted == null) - throw new ArgumentNullException("onCompleted"); - - return DoHelper(source, onNext, _ => { }, onCompleted); - } - - /// - /// Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Action to invoke on exceptional termination of the sequence. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IEnumerable Do(this IEnumerable source, Action onNext, Action onError) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onError == null) - throw new ArgumentNullException("onError"); - - return DoHelper(source, onNext, onError, () => { }); - } - - /// - /// Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Action to invoke for each element. - /// Action to invoke on exceptional termination of the sequence. - /// Action to invoke on successful termination of the sequence. - /// Sequence exhibiting the specified side-effects upon enumeration. - public static IEnumerable Do(this IEnumerable source, Action onNext, Action onError, Action onCompleted) - { - if (source == null) - throw new ArgumentNullException("source"); - if (onNext == null) - throw new ArgumentNullException("onNext"); - if (onError == null) - throw new ArgumentNullException("onError"); - if (onCompleted == null) - throw new ArgumentNullException("onCompleted"); - - return DoHelper(source, onNext, onError, onCompleted); - } - -#if !NO_RXINTERFACES - /// - /// Lazily invokes observer methods for each value in the sequence, and upon successful or exceptional termination. - /// - /// Source sequence element type. - /// Source sequence. - /// Observer to invoke notification calls on. - /// Sequence exhibiting the side-effects of observer method invocation upon enumeration. - public static IEnumerable Do(this IEnumerable source, IObserver observer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (observer == null) - throw new ArgumentNullException("observer"); - - return DoHelper(source, observer.OnNext, observer.OnError, observer.OnCompleted); - } -#endif - - private static IEnumerable DoHelper(this IEnumerable source, Action onNext, Action onError, Action onCompleted) - { - using (var e = source.GetEnumerator()) - { - while (true) - { - var current = default(TSource); - try - { - if (!e.MoveNext()) - break; - - current = e.Current; - } - catch (Exception ex) - { - onError(ex); - throw; - } - - onNext(current); - yield return current; - } - - onCompleted(); - } - } - - /// - /// Generates a sequence of non-overlapping adjacent buffers over the source sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of elements for allocated buffers. - /// Sequence of buffers containing source sequence elements. - public static IEnumerable> Buffer(this IEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count <= 0) - throw new ArgumentOutOfRangeException("count"); - - return source.Buffer_(count, count); - } - - /// - /// Generates a sequence of buffers over the source sequence, with specified length and possible overlap. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of elements for allocated buffers. - /// Number of elements to skip between the start of consecutive buffers. - /// Sequence of buffers containing source sequence elements. - public static IEnumerable> Buffer(this IEnumerable source, int count, int skip) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count <= 0) - throw new ArgumentOutOfRangeException("count"); - if (skip <= 0) - throw new ArgumentOutOfRangeException("skip"); - - return source.Buffer_(count, skip); - } - - private static IEnumerable> Buffer_(this IEnumerable source, int count, int skip) - { - var buffers = new Queue>(); - - var i = 0; - foreach (var item in source) - { - if (i % skip == 0) - buffers.Enqueue(new List(count)); - - foreach (var buffer in buffers) - buffer.Add(item); - - if (buffers.Count > 0 && buffers.Peek().Count == count) - yield return buffers.Dequeue(); - - i++; - } - - while (buffers.Count > 0) - yield return buffers.Dequeue(); - } - - /// - /// Ignores all elements in the source sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// Source sequence without its elements. - public static IEnumerable IgnoreElements(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.IgnoreElements_(); - } - - private static IEnumerable IgnoreElements_(this IEnumerable source) - { - foreach (var item in source) - ; - - yield break; - } - - /// - /// Returns elements with a distinct key value by using the default equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Sequence that contains the elements from the source sequence with distinct key values. - public static IEnumerable Distinct(this IEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.Distinct_(keySelector, EqualityComparer.Default); - } - - /// - /// Returns elements with a distinct key value by using the specified equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Comparer used to compare key values. - /// Sequence that contains the elements from the source sequence with distinct key values. - public static IEnumerable Distinct(this IEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.Distinct_(keySelector, comparer); - } - - private static IEnumerable Distinct_(this IEnumerable source, Func keySelector, IEqualityComparer comparer) - { - var set = new HashSet(comparer); - - foreach (var item in source) - { - var key = keySelector(item); - if (set.Add(key)) - yield return item; - } - } - -#if NO_HASHSET - class HashSet - { - private Dictionary _set; - - public HashSet(IEqualityComparer comparer) - { - _set = new Dictionary(comparer); - } - - public bool Add(T value) - { - if (_set.ContainsKey(value)) - return false; - - _set[value] = null; - return true; - } - } -#endif - - /// - /// Returns consecutive distinct elements by using the default equality comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Sequence without adjacent non-distinct elements. - public static IEnumerable DistinctUntilChanged(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.DistinctUntilChanged_(x => x, EqualityComparer.Default); - } - - /// - /// Returns consecutive distinct elements by using the specified equality comparer to compare values. - /// - /// Source sequence element type. - /// Source sequence. - /// Comparer used to compare values. - /// Sequence without adjacent non-distinct elements. - public static IEnumerable DistinctUntilChanged(this IEnumerable source, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.DistinctUntilChanged_(x => x, comparer); - } - - /// - /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Sequence without adjacent non-distinct elements. - public static IEnumerable DistinctUntilChanged(this IEnumerable source, Func keySelector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - - return source.DistinctUntilChanged_(keySelector, EqualityComparer.Default); - } - - /// - /// Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. - /// - /// Source sequence element type. - /// Key type. - /// Source sequence. - /// Key selector. - /// Comparer used to compare key values. - /// Sequence without adjacent non-distinct elements. - public static IEnumerable DistinctUntilChanged(this IEnumerable source, Func keySelector, IEqualityComparer comparer) - { - if (source == null) - throw new ArgumentNullException("source"); - if (keySelector == null) - throw new ArgumentNullException("keySelector"); - if (comparer == null) - throw new ArgumentNullException("comparer"); - - return source.DistinctUntilChanged_(keySelector, comparer); - } - - private static IEnumerable DistinctUntilChanged_(this IEnumerable source, Func keySelector, IEqualityComparer comparer) - { - var currentKey = default(TKey); - var hasCurrentKey = false; - - foreach (var item in source) - { - var key = keySelector(item); - - var comparerEquals = false; - if (hasCurrentKey) - { - comparerEquals = comparer.Equals(currentKey, key); - } - - if (!hasCurrentKey || !comparerEquals) - { - hasCurrentKey = true; - currentKey = key; - yield return item; - } - } - } - - /// - /// Expands the sequence by recursively applying a selector function. - /// - /// Source sequence element type. - /// Source sequence. - /// Selector function to retrieve the next sequence to expand. - /// Sequence with results from the recursive expansion of the source sequence. - public static IEnumerable Expand(this IEnumerable source, Func> selector) - { - if (source == null) - throw new ArgumentNullException("source"); - if (selector == null) - throw new ArgumentNullException("selector"); - - return source.Expand_(selector); - } - - private static IEnumerable Expand_(this IEnumerable source, Func> selector) - { - var queue = new Queue>(); - queue.Enqueue(source); - - while (queue.Count > 0) - { - var src = queue.Dequeue(); - - foreach (var item in src) - { - queue.Enqueue(selector(item)); - yield return item; - } - } - } - - /// - /// Returns the source sequence prefixed with the specified value. - /// - /// Source sequence element type. - /// Source sequence. - /// Values to prefix the sequence with. - /// Sequence starting with the specified prefix value, followed by the source sequence. - public static IEnumerable StartWith(this IEnumerable source, params TSource[] values) - { - if (source == null) - throw new ArgumentNullException("source"); - - return source.StartWith_(values); - } - - private static IEnumerable StartWith_(this IEnumerable source, params TSource[] values) - { - foreach (var x in values) - yield return x; - - foreach (var item in source) - yield return item; - } - - /// - /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. - /// - /// Source sequence element type. - /// Accumulation type. - /// Source sequence. - /// Accumulator seed value. - /// Accumulation function to apply to the current accumulation value and each element of the sequence. - /// Sequence with all intermediate accumulation values resulting from scanning the sequence. - public static IEnumerable Scan(this IEnumerable source, TAccumulate seed, Func accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return source.Scan_(seed, accumulator); - } - - private static IEnumerable Scan_(this IEnumerable source, TAccumulate seed, Func accumulator) - { - var acc = seed; - - foreach (var item in source) - { - acc = accumulator(acc, item); - yield return acc; - } - } - - /// - /// Generates a sequence of accumulated values by scanning the source sequence and applying an accumulator function. - /// - /// Source sequence element type. - /// Source sequence. - /// Accumulation function to apply to the current accumulation value and each element of the sequence. - /// Sequence with all intermediate accumulation values resulting from scanning the sequence. - public static IEnumerable Scan(this IEnumerable source, Func accumulator) - { - if (source == null) - throw new ArgumentNullException("source"); - if (accumulator == null) - throw new ArgumentNullException("accumulator"); - - return source.Scan_(accumulator); - } - - private static IEnumerable Scan_(this IEnumerable source, Func accumulator) - { - var hasSeed = false; - var acc = default(TSource); - - foreach (var item in source) - { - if (!hasSeed) - { - hasSeed = true; - acc = item; - continue; - } - - acc = accumulator(acc, item); - yield return acc; - } - } - - /// - /// Returns a specified number of contiguous elements from the end of the sequence. - /// - /// Source sequence element type. - /// Source sequence. - /// The number of elements to take from the end of the sequence. - /// Sequence with the specified number of elements counting from the end of the source sequence. - public static IEnumerable TakeLast(this IEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return source.TakeLast_(count); - } - - private static IEnumerable TakeLast_(this IEnumerable source, int count) - { - var q = new Queue(count); - - foreach (var item in source) - { - if (q.Count >= count) - q.Dequeue(); - q.Enqueue(item); - } - - while (q.Count > 0) - yield return q.Dequeue(); - } - - /// - /// Bypasses a specified number of contiguous elements from the end of the sequence and returns the remaining elements. - /// - /// Source sequence element type. - /// Source sequence. - /// The number of elements to skip from the end of the sequence before returning the remaining elements. - /// Sequence bypassing the specified number of elements counting from the end of the source sequence. - public static IEnumerable SkipLast(this IEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return source.SkipLast_(count); - } - - private static IEnumerable SkipLast_(this IEnumerable source, int count) - { - var q = new Queue(); - - foreach (var x in source) - { - q.Enqueue(x); - if (q.Count > count) - yield return q.Dequeue(); - } - } - - /// - /// Repeats and concatenates the source sequence infinitely. - /// - /// Source sequence element type. - /// Source sequence. - /// Sequence obtained by concatenating the source sequence to itself infinitely. - public static IEnumerable Repeat(this IEnumerable source) - { - if (source == null) - throw new ArgumentNullException("source"); - - return Repeat_(source); - } - - private static IEnumerable Repeat_(IEnumerable source) - { - while (true) - foreach (var item in source) - yield return item; - } - - /// - /// Repeats and concatenates the source sequence the given number of times. - /// - /// Source sequence element type. - /// Source sequence. - /// Number of times to repeat the source sequence. - /// Sequence obtained by concatenating the source sequence to itself the specified number of times. - public static IEnumerable Repeat(this IEnumerable source, int count) - { - if (source == null) - throw new ArgumentNullException("source"); - if (count < 0) - throw new ArgumentOutOfRangeException("count"); - - return Repeat_(source, count); - } - - private static IEnumerable Repeat_(IEnumerable source, int count) - { - for (var i = 0; i < count; i++) - foreach (var item in source) - yield return item; - } - } -} diff --git a/Ix/System.Interactive/Properties/AssemblyInfo.cs b/Ix/System.Interactive/Properties/AssemblyInfo.cs deleted file mode 100644 index 0bafb78..0000000 --- a/Ix/System.Interactive/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,37 +0,0 @@ -using System; -using System.Reflection; -using System.Resources; -using System.Runtime.InteropServices; -using System.Security; - -[assembly: AssemblyTitle("System.Interactive")] -// Notice: same description as in the .nuspec files; see Source/Interactive Extensions/Setup/NuGet -[assembly: AssemblyDescription("Interactive Extensions Main Library used to express queries over enumerable sequences.")] -#if DEBUG -[assembly: AssemblyConfiguration("Debug")] -#else -[assembly: AssemblyConfiguration("Retail")] -#endif -[assembly: AssemblyCompany("Microsoft Corporation")] -#if STABLE -[assembly: AssemblyProduct("Interactive Extensions")] -#else -[assembly: AssemblyProduct("Interactive Extensions (Experimental Release)")] -#endif -[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")] -[assembly: NeutralResourcesLanguage("en-US")] - -#if !PLIB -[assembly: ComVisible(false)] -#endif - -[assembly: CLSCompliant(true)] - -#if DESKTOPCLR && NO_CODECOVERAGE -[assembly: AllowPartiallyTrustedCallers] -#endif - -// -// Note: Assembly (file) version numbers get inserted by the build system on the fly. Inspect the Team Build workflows -// and the custom activity in Build/Source/Activities/AppendVersionInfo.cs for more information. -// diff --git a/Ix/System.Interactive/System.Interactive.csproj b/Ix/System.Interactive/System.Interactive.csproj deleted file mode 100644 index a4646a5..0000000 --- a/Ix/System.Interactive/System.Interactive.csproj +++ /dev/null @@ -1,41 +0,0 @@ - - - - Debug - AnyCPU - 8.0.30703 - 2.0 - {8E4B04F0-915E-48F9-9796-76278C6094BD} - Library - Properties - System.Interactive - System.Interactive - v4.0 - 512 - true - - - - $(OutputPath)\$(AssemblyName).XML - - - Profile1 - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/Ix/Tests/App.cs b/Ix/Tests/App.cs deleted file mode 100644 index 3f27e96..0000000 --- a/Ix/Tests/App.cs +++ /dev/null @@ -1,47 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if SILVERLIGHT && !SILVERLIGHTM7 -using System; -using System.Diagnostics; -using System.Windows; -using System.Windows.Browser; -using Microsoft.Silverlight.Testing; - -namespace InteractiveTests -{ - public class App : Application - { - public App() - { - this.Startup += (o, e) => - { - // TODO: Investigate UnitTestSettings configuration of TestService and LogProviders. - // var settings = new UnitTestSettings { StartRunImmediately = true }; - RootVisual = UnitTestSystem.CreateTestPage(/* settings */); - }; - - this.UnhandledException += (o, e) => - { - if (!Debugger.IsAttached) - { - e.Handled = true; - Deployment.Current.Dispatcher.BeginInvoke(delegate { ReportErrorToDOM(e); }); - } - }; - } - - private void ReportErrorToDOM(ApplicationUnhandledExceptionEventArgs e) - { - try - { - string errorMsg = e.ExceptionObject.Message + e.ExceptionObject.StackTrace; - errorMsg = errorMsg.Replace('"', '\'').Replace("\r\n", @"\n"); - - HtmlPage.Window.Eval("throw new Error(\"Unhandled Error in Silverlight Application " + errorMsg + "\");"); - } - catch (Exception) - { - } - } - } -} -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Aggregates.cs b/Ix/Tests/AsyncTests.Aggregates.cs deleted file mode 100644 index 1e43178..0000000 --- a/Ix/Tests/AsyncTests.Aggregates.cs +++ /dev/null @@ -1,2168 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Collections; -using System.Threading; - -namespace Tests -{ - public partial class AsyncTests - { - [TestMethod] - public void Aggregate_Null() - { - AssertThrows(() => AsyncEnumerable.Aggregate(null, (x, y) => x + y)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null)); - - AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y, z => z)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null, z => z)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null)); - - AssertThrows(() => AsyncEnumerable.Aggregate(null, (x, y) => x + y, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Aggregate(null, 0, (x, y) => x + y, z => z, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, null, z => z, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Aggregate(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null, CancellationToken.None)); - } - - [TestMethod] - public void Aggregate1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate((x, y) => x * y); - Assert.AreEqual(ys.Result, 24); - } - - [TestMethod] - public void Aggregate2() - { - var xs = new int[0].ToAsyncEnumerable(); - var ys = xs.Aggregate((x, y) => x * y); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Aggregate3() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Aggregate((x, y) => x * y); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Aggregate4() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate((x, y) => { throw ex; }); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Aggregate5() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => x * y); - Assert.AreEqual(ys.Result, 24); - } - - [TestMethod] - public void Aggregate6() - { - var xs = new int[0].ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => x * y); - Assert.AreEqual(ys.Result, 1); - } - - [TestMethod] - public void Aggregate7() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Aggregate(1, (x, y) => x * y); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Aggregate8() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => { throw ex; }); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Aggregate9() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1); - Assert.AreEqual(ys.Result, 25); - } - - [TestMethod] - public void Aggregate10() - { - var xs = new int[0].ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1); - Assert.AreEqual(ys.Result, 2); - } - - [TestMethod] - public void Aggregate11() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Aggregate12() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => { throw ex; }, x => x + 1); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Aggregate13() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Aggregate(1, (x, y) => x * y, x => { throw ex; }); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Count_Null() - { - AssertThrows(() => AsyncEnumerable.Count(null)); - AssertThrows(() => AsyncEnumerable.Count(null, x => true)); - AssertThrows(() => AsyncEnumerable.Count(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Count(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Count(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Count(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void Count1() - { - Assert.AreEqual(new int[0].ToAsyncEnumerable().Count().Result, 0); - Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count().Result, 3); - AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).Count().Wait()); - } - - [TestMethod] - public void Count2() - { - Assert.AreEqual(new int[0].ToAsyncEnumerable().Count(x => x < 3).Result, 0); - Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => x < 3).Result, 2); - AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).Count(x => x < 3).Wait()); - } - - [TestMethod] - public void Count3() - { - var ex = new Exception("Bang!"); - var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => { throw ex; }); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void LongCount_Null() - { - AssertThrows(() => AsyncEnumerable.LongCount(null)); - AssertThrows(() => AsyncEnumerable.LongCount(null, x => true)); - AssertThrows(() => AsyncEnumerable.LongCount(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.LongCount(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.LongCount(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.LongCount(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void LongCount1() - { - Assert.AreEqual(new int[0].ToAsyncEnumerable().LongCount().Result, 0); - Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount().Result, 3); - AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).LongCount().Wait()); - } - - [TestMethod] - public void LongCount2() - { - Assert.AreEqual(new int[0].ToAsyncEnumerable().LongCount(x => x < 3).Result, 0); - Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => x < 3).Result, 2); - AssertThrows(() => AsyncEnumerable.Throw(new Exception("Bang!")).LongCount(x => x < 3).Wait()); - } - - [TestMethod] - public void LongCount3() - { - var ex = new Exception("Bang!"); - var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => { throw ex; }); - AssertThrows(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void All_Null() - { - AssertThrows(() => AsyncEnumerable.All(null, x => true)); - AssertThrows(() => AsyncEnumerable.All(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.All(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.All(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void All1() - { - var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void All2() - { - var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void All3() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).All(x => x % 2 == 0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void All4() - { - var ex = new Exception("Bang!"); - var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => { throw ex; }); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Any_Null() - { - AssertThrows(() => AsyncEnumerable.Any(null)); - AssertThrows(() => AsyncEnumerable.Any(null, x => true)); - AssertThrows(() => AsyncEnumerable.Any(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Any(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Any(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Any(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void Any1() - { - var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any(x => x % 2 == 0); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void Any2() - { - var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => x % 2 != 0); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void Any3() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).Any(x => x % 2 == 0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Any4() - { - var ex = new Exception("Bang!"); - var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => { throw ex; }); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Any5() - { - var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any(); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void Any6() - { - var res = new int[0].ToAsyncEnumerable().Any(); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void Contains_Null() - { - AssertThrows(() => AsyncEnumerable.Contains(null, 42)); - AssertThrows(() => AsyncEnumerable.Contains(null, 42, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Contains(AsyncEnumerable.Return(42), 42, null)); - - AssertThrows(() => AsyncEnumerable.Contains(null, 42, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Contains(null, 42, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Contains(AsyncEnumerable.Return(42), 42, null, CancellationToken.None)); - } - - [TestMethod] - public void Contains1() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); - var ys = xs.Contains(3); - Assert.IsTrue(ys.Result); - } - - [TestMethod] - public void Contains2() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); - var ys = xs.Contains(6); - Assert.IsFalse(ys.Result); - } - - [TestMethod] - public void Contains3() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); - var ys = xs.Contains(-3, new Eq()); - Assert.IsTrue(ys.Result); - } - - [TestMethod] - public void Contains4() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable(); - var ys = xs.Contains(-6, new Eq()); - Assert.IsFalse(ys.Result); - } - - class Eq : IEqualityComparer - { - public bool Equals(int x, int y) - { - return EqualityComparer.Default.Equals(Math.Abs(x), Math.Abs(y)); - } - - public int GetHashCode(int obj) - { - return EqualityComparer.Default.GetHashCode(Math.Abs(obj)); - } - } - - [TestMethod] - public void First_Null() - { - AssertThrows(() => AsyncEnumerable.First(null)); - AssertThrows(() => AsyncEnumerable.First(null, x => true)); - AssertThrows(() => AsyncEnumerable.First(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.First(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.First(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.First(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void First1() - { - var res = AsyncEnumerable.Empty().First(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void First2() - { - var res = AsyncEnumerable.Empty().First(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void First3() - { - var res = AsyncEnumerable.Return(42).First(x => x % 2 != 0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void First4() - { - var res = AsyncEnumerable.Return(42).First(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void First5() - { - var res = AsyncEnumerable.Return(42).First(x => x % 2 == 0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void First6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).First(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void First7() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).First(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void First8() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void First9() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First(x => x % 2 != 0); - Assert.AreEqual(45, res.Result); - } - - [TestMethod] - public void FirstOrDefault_Null() - { - AssertThrows(() => AsyncEnumerable.FirstOrDefault(null)); - AssertThrows(() => AsyncEnumerable.FirstOrDefault(null, x => true)); - AssertThrows(() => AsyncEnumerable.FirstOrDefault(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.FirstOrDefault(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.FirstOrDefault(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.FirstOrDefault(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void FirstOrDefault1() - { - var res = AsyncEnumerable.Empty().FirstOrDefault(); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void FirstOrDefault2() - { - var res = AsyncEnumerable.Empty().FirstOrDefault(x => true); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void FirstOrDefault3() - { - var res = AsyncEnumerable.Return(42).FirstOrDefault(x => x % 2 != 0); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void FirstOrDefault4() - { - var res = AsyncEnumerable.Return(42).FirstOrDefault(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void FirstOrDefault5() - { - var res = AsyncEnumerable.Return(42).FirstOrDefault(x => x % 2 == 0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void FirstOrDefault6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).FirstOrDefault(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void FirstOrDefault7() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).FirstOrDefault(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void FirstOrDefault8() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void FirstOrDefault9() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x % 2 != 0); - Assert.AreEqual(45, res.Result); - } - - [TestMethod] - public void FirstOrDefault10() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x < 10); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void Last_Null() - { - AssertThrows(() => AsyncEnumerable.Last(null)); - AssertThrows(() => AsyncEnumerable.Last(null, x => true)); - AssertThrows(() => AsyncEnumerable.Last(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Last(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Last(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Last(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void Last1() - { - var res = AsyncEnumerable.Empty().Last(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Last2() - { - var res = AsyncEnumerable.Empty().Last(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Last3() - { - var res = AsyncEnumerable.Return(42).Last(x => x % 2 != 0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Last4() - { - var res = AsyncEnumerable.Return(42).Last(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void Last5() - { - var res = AsyncEnumerable.Return(42).Last(x => x % 2 == 0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void Last6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).Last(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Last7() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).Last(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Last8() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Last(); - Assert.AreEqual(90, res.Result); - } - - [TestMethod] - public void Last9() - { - var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Last(x => x % 2 != 0); - Assert.AreEqual(45, res.Result); - } - - [TestMethod] - public void LastOrDefault_Null() - { - AssertThrows(() => AsyncEnumerable.LastOrDefault(null)); - AssertThrows(() => AsyncEnumerable.LastOrDefault(null, x => true)); - AssertThrows(() => AsyncEnumerable.LastOrDefault(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.LastOrDefault(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.LastOrDefault(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.LastOrDefault(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void LastOrDefault1() - { - var res = AsyncEnumerable.Empty().LastOrDefault(); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void LastOrDefault2() - { - var res = AsyncEnumerable.Empty().LastOrDefault(x => true); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void LastOrDefault3() - { - var res = AsyncEnumerable.Return(42).LastOrDefault(x => x % 2 != 0); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void LastOrDefault4() - { - var res = AsyncEnumerable.Return(42).LastOrDefault(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void LastOrDefault5() - { - var res = AsyncEnumerable.Return(42).LastOrDefault(x => x % 2 == 0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void LastOrDefault6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).LastOrDefault(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void LastOrDefault7() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).LastOrDefault(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void LastOrDefault8() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault(); - Assert.AreEqual(90, res.Result); - } - - [TestMethod] - public void LastOrDefault9() - { - var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x % 2 != 0); - Assert.AreEqual(45, res.Result); - } - - [TestMethod] - public void LastOrDefault10() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x < 10); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void Single_Null() - { - AssertThrows(() => AsyncEnumerable.Single(null)); - AssertThrows(() => AsyncEnumerable.Single(null, x => true)); - AssertThrows(() => AsyncEnumerable.Single(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Single(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Single(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Single(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void Single1() - { - var res = AsyncEnumerable.Empty().Single(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Single2() - { - var res = AsyncEnumerable.Empty().Single(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Single3() - { - var res = AsyncEnumerable.Return(42).Single(x => x % 2 != 0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Single4() - { - var res = AsyncEnumerable.Return(42).Single(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void Single5() - { - var res = AsyncEnumerable.Return(42).Single(x => x % 2 == 0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void Single6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).Single(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Single7() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).Single(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Single8() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Single9() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0); - Assert.AreEqual(45, res.Result); - } - - [TestMethod] - public void Single10() - { - var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void SingleOrDefault_Null() - { - AssertThrows(() => AsyncEnumerable.SingleOrDefault(null)); - AssertThrows(() => AsyncEnumerable.SingleOrDefault(null, x => true)); - AssertThrows(() => AsyncEnumerable.SingleOrDefault(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.SingleOrDefault(null, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.SingleOrDefault(null, x => true, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.SingleOrDefault(AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void SingleOrDefault1() - { - var res = AsyncEnumerable.Empty().SingleOrDefault(); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void SingleOrDefault2() - { - var res = AsyncEnumerable.Empty().SingleOrDefault(x => true); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void SingleOrDefault3() - { - var res = AsyncEnumerable.Return(42).SingleOrDefault(x => x % 2 != 0); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void SingleOrDefault4() - { - var res = AsyncEnumerable.Return(42).SingleOrDefault(); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void SingleOrDefault5() - { - var res = AsyncEnumerable.Return(42).SingleOrDefault(x => x % 2 == 0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void SingleOrDefault6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).SingleOrDefault(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SingleOrDefault7() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).SingleOrDefault(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SingleOrDefault8() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void SingleOrDefault9() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x % 2 != 0); - Assert.AreEqual(45, res.Result); - } - - [TestMethod] - public void SingleOrDefault10() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x < 10); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void SingleOrDefault11() - { - var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => true); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void ElementAt_Null() - { - AssertThrows(() => AsyncEnumerable.ElementAt(null, 0)); - AssertThrows(() => AsyncEnumerable.ElementAt(AsyncEnumerable.Return(42), -1)); - - AssertThrows(() => AsyncEnumerable.ElementAt(null, 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ElementAt(AsyncEnumerable.Return(42), -1, CancellationToken.None)); - } - - [TestMethod] - public void ElementAt1() - { - var res = AsyncEnumerable.Empty().ElementAt(0); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException); - } - - [TestMethod] - public void ElementAt2() - { - var res = AsyncEnumerable.Return(42).ElementAt(0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void ElementAt3() - { - var res = AsyncEnumerable.Return(42).ElementAt(1); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException); - } - - [TestMethod] - public void ElementAt4() - { - var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(1); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void ElementAt5() - { - var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(7); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException); - } - - [TestMethod] - public void ElementAt6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).ElementAt(15); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ElementAtOrDefault_Null() - { - AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(null, 0)); - AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(AsyncEnumerable.Return(42), -1)); - - AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(null, 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ElementAtOrDefault(AsyncEnumerable.Return(42), -1, CancellationToken.None)); - } - - [TestMethod] - public void ElementAtOrDefault1() - { - var res = AsyncEnumerable.Empty().ElementAtOrDefault(0); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void ElementAtOrDefault2() - { - var res = AsyncEnumerable.Return(42).ElementAtOrDefault(0); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void ElementAtOrDefault3() - { - var res = AsyncEnumerable.Return(42).ElementAtOrDefault(1); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void ElementAtOrDefault4() - { - var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(1); - Assert.AreEqual(42, res.Result); - } - - [TestMethod] - public void ElementAtOrDefault5() - { - var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(7); - Assert.AreEqual(0, res.Result); - } - - [TestMethod] - public void ElementAtOrDefault6() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).ElementAtOrDefault(15); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ToList_Null() - { - AssertThrows(() => AsyncEnumerable.ToList(null)); - AssertThrows(() => AsyncEnumerable.ToList(null, CancellationToken.None)); - } - - [TestMethod] - public void ToList1() - { - var xs = new[] { 42, 25, 39 }; - var res = xs.ToAsyncEnumerable().ToList(); - Assert.IsTrue(res.Result.SequenceEqual(xs)); - } - - [TestMethod] - public void ToList2() - { - var xs = AsyncEnumerable.Empty(); - var res = xs.ToList(); - Assert.IsTrue(res.Result.Count == 0); - } - - [TestMethod] - public void ToList3() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).ToList(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ToArray_Null() - { - AssertThrows(() => AsyncEnumerable.ToArray(null)); - AssertThrows(() => AsyncEnumerable.ToArray(null, CancellationToken.None)); - } - - [TestMethod] - public void ToArray1() - { - var xs = new[] { 42, 25, 39 }; - var res = xs.ToAsyncEnumerable().ToArray(); - Assert.IsTrue(res.Result.SequenceEqual(xs)); - } - - [TestMethod] - public void ToArray2() - { - var xs = AsyncEnumerable.Empty(); - var res = xs.ToArray(); - Assert.IsTrue(res.Result.Length == 0); - } - - [TestMethod] - public void ToArray3() - { - var ex = new Exception("Bang!"); - var res = AsyncEnumerable.Throw(ex).ToArray(); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ToDictionary_Null() - { - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, x => 0, null)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.ToDictionary(null, x => 0, x => 0, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToDictionary(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None)); - } - - [TestMethod] - public void ToDictionary1() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToDictionary(x => x % 2).Result; - Assert.IsTrue(res[0] == 4); - Assert.IsTrue(res[1] == 1); - } - - [TestMethod] - public void ToDictionary2() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - AssertThrows(() => xs.ToDictionary(x => x % 2).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException); - } - - [TestMethod] - public void ToDictionary3() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToDictionary(x => x % 2, x => x + 1).Result; - Assert.IsTrue(res[0] == 5); - Assert.IsTrue(res[1] == 2); - } - - [TestMethod] - public void ToDictionary4() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - AssertThrows(() => xs.ToDictionary(x => x % 2, x => x + 1).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException); - } - - [TestMethod] - public void ToDictionary5() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToDictionary(x => x % 2, new Eq()).Result; - Assert.IsTrue(res[0] == 4); - Assert.IsTrue(res[1] == 1); - } - - [TestMethod] - public void ToDictionary6() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - AssertThrows(() => xs.ToDictionary(x => x % 2, new Eq()).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException); - } - - [TestMethod] - public void ToDictionary7() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToDictionary(x => x % 2, x => x, new Eq()).Result; - Assert.IsTrue(res[0] == 4); - Assert.IsTrue(res[1] == 1); - } - - [TestMethod] - public void ToLookup_Null() - { - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, x => 0, null)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.ToLookup(null, x => 0, x => 0, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ToLookup(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None)); - } - - [TestMethod] - public void ToLookup1() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(4)); - Assert.IsTrue(res[1].Contains(1)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void ToLookup2() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(4)); - Assert.IsTrue(res[0].Contains(2)); - Assert.IsTrue(res[1].Contains(1)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void ToLookup3() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2, x => x + 1).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(5)); - Assert.IsTrue(res[1].Contains(2)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void ToLookup4() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2, x => x + 1).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(5)); - Assert.IsTrue(res[0].Contains(3)); - Assert.IsTrue(res[1].Contains(2)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void ToLookup5() - { - var xs = new[] { 1, 4 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2, new Eq()).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(4)); - Assert.IsTrue(res[1].Contains(1)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void ToLookup6() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2, new Eq()).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(4)); - Assert.IsTrue(res[0].Contains(2)); - Assert.IsTrue(res[1].Contains(1)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void ToLookup7() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2).Result; - foreach (var g in res) - Assert.IsTrue(g.Key == 0 || g.Key == 1); - } - - [TestMethod] - public void ToLookup8() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2).Result; - foreach (IGrouping g in (IEnumerable)res) - Assert.IsTrue(g.Key == 0 || g.Key == 1); - } - - [TestMethod] - public void ToLookup9() - { - var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); - var res = xs.ToLookup(x => x % 2, x => x, new Eq()).Result; - Assert.IsTrue(res.Contains(0)); - Assert.IsTrue(res.Contains(1)); - Assert.IsTrue(res[0].Contains(4)); - Assert.IsTrue(res[0].Contains(2)); - Assert.IsTrue(res[1].Contains(1)); - Assert.IsTrue(res.Count == 2); - } - - [TestMethod] - public void Average_Null() - { - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable))); - - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x)); - - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func))); - - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(default(IAsyncEnumerable), x => x, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Average(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - } - - [TestMethod] - public void Average1() - { - var xs = new[] { 1, 2, 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average2() - { - var xs = new[] { 1, default(int?), 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average3() - { - var xs = new[] { 1L, 2L, 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average4() - { - var xs = new[] { 1L, default(long?), 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average5() - { - var xs = new[] { 1.0, 2.0, 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average6() - { - var xs = new[] { 1.0, default(double?), 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average7() - { - var xs = new[] { 1.0f, 2.0f, 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average8() - { - var xs = new[] { 1.0f, default(float?), 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average9() - { - var xs = new[] { 1.0m, 2.0m, 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average10() - { - var xs = new[] { 1.0m, default(decimal?), 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Average(), ys.Average().Result); - Assert.AreEqual(xs.Average(), ys.Average(x => x).Result); - } - - [TestMethod] - public void Average11() - { - var xs = new int[0]; - var ys = xs.ToAsyncEnumerable(); - AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Average12() - { - var xs = new int?[0]; - var ys = xs.ToAsyncEnumerable(); - Assert.IsNull(ys.Average().Result); - } - - [TestMethod] - public void Average13() - { - var xs = new long[0]; - var ys = xs.ToAsyncEnumerable(); - AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Average14() - { - var xs = new long?[0]; - var ys = xs.ToAsyncEnumerable(); - Assert.IsNull(ys.Average().Result); - } - - [TestMethod] - public void Average15() - { - var xs = new double[0]; - var ys = xs.ToAsyncEnumerable(); - AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Average16() - { - var xs = new double?[0]; - var ys = xs.ToAsyncEnumerable(); - Assert.IsNull(ys.Average().Result); - } - - [TestMethod] - public void Average17() - { - var xs = new float[0]; - var ys = xs.ToAsyncEnumerable(); - AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Average18() - { - var xs = new float?[0]; - var ys = xs.ToAsyncEnumerable(); - Assert.IsNull(ys.Average().Result); - } - - [TestMethod] - public void Average19() - { - var xs = new decimal[0]; - var ys = xs.ToAsyncEnumerable(); - AssertThrows(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void Average20() - { - var xs = new decimal?[0]; - var ys = xs.ToAsyncEnumerable(); - Assert.IsNull(ys.Average().Result); - } - - [TestMethod] - public void Min_Null() - { - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func))); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), Comparer.Default)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(IComparer))); - - AssertThrows(() => AsyncEnumerable.Min(default(IAsyncEnumerable), Comparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Min(AsyncEnumerable.Empty(), default(IComparer), CancellationToken.None)); - } - - [TestMethod] - public void Min1() - { - var xs = new[] { 2, 1, 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min2() - { - var xs = new[] { 2, default(int?), 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min3() - { - var xs = new[] { 2L, 1L, 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min4() - { - var xs = new[] { 2L, default(long?), 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min5() - { - var xs = new[] { 2.0, 1.0, 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min6() - { - var xs = new[] { 2.0, default(double?), 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min7() - { - var xs = new[] { 2.0f, 1.0f, 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min8() - { - var xs = new[] { 2.0f, default(float?), 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min9() - { - var xs = new[] { 2.0m, 1.0m, 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min10() - { - var xs = new[] { 2.0m, default(decimal?), 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Min11() - { - var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Min(), ys.Min().Result); - Assert.AreEqual(xs.Min(), ys.Min(x => x).Result); - } - - [TestMethod] - public void Max_Null() - { - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func))); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), Comparer.Default)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(IComparer))); - - AssertThrows(() => AsyncEnumerable.Max(default(IAsyncEnumerable), Comparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Max(AsyncEnumerable.Empty(), default(IComparer), CancellationToken.None)); - } - - [TestMethod] - public void Max1() - { - var xs = new[] { 2, 7, 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max2() - { - var xs = new[] { 2, default(int?), 3, 1 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max3() - { - var xs = new[] { 2L, 7L, 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max4() - { - var xs = new[] { 2L, default(long?), 3L, 1L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max5() - { - var xs = new[] { 2.0, 7.0, 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max6() - { - var xs = new[] { 2.0, default(double?), 3.0, 1.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max7() - { - var xs = new[] { 2.0f, 7.0f, 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max8() - { - var xs = new[] { 2.0f, default(float?), 3.0f, 1.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max9() - { - var xs = new[] { 2.0m, 7.0m, 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max10() - { - var xs = new[] { 2.0m, default(decimal?), 3.0m, 1.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Max11() - { - var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Max(), ys.Max().Result); - Assert.AreEqual(xs.Max(), ys.Max(x => x).Result); - } - - [TestMethod] - public void Sum_Null() - { - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable))); - - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x)); - - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func))); - - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(default(IAsyncEnumerable), x => x, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty(), default(Func), CancellationToken.None)); - } - - [TestMethod] - public void Sum1() - { - var xs = new[] { 1, 2, 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum2() - { - var xs = new[] { 1, default(int?), 3 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum3() - { - var xs = new[] { 1L, 2L, 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum4() - { - var xs = new[] { 1L, default(long?), 3L }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum5() - { - var xs = new[] { 1.0, 2.0, 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum6() - { - var xs = new[] { 1.0, default(double?), 3.0 }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum7() - { - var xs = new[] { 1.0f, 2.0f, 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum8() - { - var xs = new[] { 1.0f, default(float?), 3.0f }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum9() - { - var xs = new[] { 1.0m, 2.0m, 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void Sum10() - { - var xs = new[] { 1.0m, default(decimal?), 3.0m }; - var ys = xs.ToAsyncEnumerable(); - Assert.AreEqual(xs.Sum(), ys.Sum().Result); - Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result); - } - - [TestMethod] - public void MinBy_Null() - { - AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func))); - - AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default)); - AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer))); - - AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable), x => x, Comparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer), CancellationToken.None)); - } - - [TestMethod] - public void MinBy1() - { - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => x / 2); - var res = xs.Result; - - Assert.IsTrue(res.SequenceEqual(new[] { 3, 2 })); - } - - [TestMethod] - public void MinBy2() - { - var xs = new int[0].ToAsyncEnumerable().MinBy(x => x / 2); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void MinBy3() - { - var ex = new Exception("Bang!"); - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 3) throw ex; return x; }); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void MinBy4() - { - var ex = new Exception("Bang!"); - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 4) throw ex; return x; }); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void MinBy5() - { - var ex = new Exception("Bang!"); - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)).MinBy(x => x, Comparer.Default); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void MaxBy_Null() - { - AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func))); - - AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default)); - AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer))); - - AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func), CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable), x => x, Comparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func), Comparer.Default, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer), CancellationToken.None)); - } - - [TestMethod] - public void MaxBy1() - { - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => x / 2); - var res = xs.Result; - - Assert.IsTrue(res.SequenceEqual(new[] { 7, 6 })); - } - - [TestMethod] - public void MaxBy2() - { - var xs = new int[0].ToAsyncEnumerable().MaxBy(x => x / 2); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException); - } - - [TestMethod] - public void MaxBy3() - { - var ex = new Exception("Bang!"); - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 3) throw ex; return x; }); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void MaxBy4() - { - var ex = new Exception("Bang!"); - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 4) throw ex; return x; }); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void MaxBy5() - { - var ex = new Exception("Bang!"); - var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)).MaxBy(x => x, Comparer.Default); - - AssertThrows(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Bugs.cs b/Ix/Tests/AsyncTests.Bugs.cs deleted file mode 100644 index 61ae7aa..0000000 --- a/Ix/Tests/AsyncTests.Bugs.cs +++ /dev/null @@ -1,266 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Collections; -using System.Threading; -using System.Threading.Tasks; -using System.Diagnostics; -//using System.Reactive.Linq; -//using System.Reactive.Concurrency; - -namespace Tests -{ - public partial class AsyncTests - { - [TestInitialize] - public void InitTests() - { - TaskScheduler.UnobservedTaskException += (o, e) => - { - }; - } - - /* - [TestMethod] - public void TestPushPopAsync() - { - var stack = new Stack(); - var count = 10; - - var observable = Observable.Generate( - 0, - i => i < count, - i => i + 1, - i => i, - i => TimeSpan.FromMilliseconds(1), // change this to 0 to avoid the problem [1] - Scheduler.ThreadPool); - - var task = DoSomethingAsync(observable, stack); - - // we give it a timeout so the test can fail instead of hang - task.Wait(TimeSpan.FromSeconds(2)); - - Assert.AreEqual(10, stack.Count); - } - - private Task DoSomethingAsync(IObservable observable, Stack stack) - { - var ae = observable - .ToAsyncEnumerable() - //.Do(i => Debug.WriteLine("Bug-fixing side effect: " + i)) // [2] - .GetEnumerator(); - - var tcs = new TaskCompletionSource(); - - var a = default(Action); - a = new Action(() => - { - ae.MoveNext().ContinueWith(t => - { - if (t.Result) - { - var i = ae.Current; - Debug.WriteLine("Doing something with " + i); - Thread.Sleep(50); - stack.Push(i); - a(); - } - else - tcs.TrySetResult(null); - }); - }); - - a(); - - return tcs.Task; - } - */ - - static IEnumerable Xs(Action a) - { - try - { - var rnd = new Random(); - - while (true) - { - yield return rnd.Next(0, 43); - Thread.Sleep(rnd.Next(0, 500)); - } - } - finally - { - a(); - } - } - - [TestMethod] - public void CorrectDispose() - { - var disposed = false; - - var xs = new[] { 1, 2, 3 }.WithDispose(() => - { - disposed = true; - }).ToAsyncEnumerable(); - - var ys = xs.Select(x => x + 1); - - var e = ys.GetEnumerator(); - e.Dispose(); - - Assert.IsTrue(disposed); - - Assert.IsFalse(e.MoveNext().Result); - } - - [TestMethod] - public void DisposesUponError() - { - var disposed = false; - - var xs = new[] { 1, 2, 3 }.WithDispose(() => - { - disposed = true; - }).ToAsyncEnumerable(); - - var ex = new Exception("Bang!"); - var ys = xs.Select(x => { if (x == 1) throw ex; return x; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext()); - - Assert.IsTrue(disposed); - } - - [TestMethod] - public void CorrectCancel() - { - var disposed = false; - - var xs = new[] { 1, 2, 3 }.WithDispose(() => - { - disposed = true; - }).ToAsyncEnumerable(); - - var ys = xs.Select(x => x + 1).Where(x => true); - - var e = ys.GetEnumerator(); - var cts = new CancellationTokenSource(); - var t = e.MoveNext(cts.Token); - - cts.Cancel(); - - try - { - t.Wait(); - } - catch - { - // Don't care about the outcome; we could have made it to element 1 - // but we could also have cancelled the MoveNext-calling task. Either - // way, we want to wait for the task to be completed and check that - } - finally - { - // the cancellation bubbled all the way up to the source to dispose - // it. This design is chosen because cancelling a MoveNext call leaves - // the enumerator in an indeterminate state. Further interactions with - // it should be forbidden. - Assert.IsTrue(disposed); - } - - Assert.IsFalse(e.MoveNext().Result); - } - - [TestMethod] - public void CanCancelMoveNext() - { - var evt = new ManualResetEvent(false); - var xs = Blocking(evt).ToAsyncEnumerable().Select(x => x).Where(x => true); - - var e = xs.GetEnumerator(); - var cts = new CancellationTokenSource(); - var t = e.MoveNext(cts.Token); - - cts.Cancel(); - - try - { - t.Wait(); - Assert.Fail(); - } - catch - { - Assert.IsTrue(t.IsCanceled); - } - - evt.Set(); - } - - static IEnumerable Blocking(ManualResetEvent evt) - { - evt.WaitOne(); - yield return 42; - } - } - - static class MyExt - { - public static IEnumerable WithDispose(this IEnumerable source, Action a) - { - return EnumerableEx.Create(() => - { - var e = source.GetEnumerator(); - return new Enumerator(e.MoveNext, () => e.Current, () => { e.Dispose(); a(); }); - }); - } - - class Enumerator : IEnumerator - { - private readonly Func _moveNext; - private readonly Func _current; - private readonly Action _dispose; - - public Enumerator(Func moveNext, Func current, Action dispose) - { - _moveNext = moveNext; - _current = current; - _dispose = dispose; - } - - public T Current - { - get { return _current(); } - } - - public void Dispose() - { - _dispose(); - } - - object IEnumerator.Current - { - get { return Current; } - } - - public bool MoveNext() - { - return _moveNext(); - } - - public void Reset() - { - throw new NotImplementedException(); - } - } - - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Conversions.cs b/Ix/Tests/AsyncTests.Conversions.cs deleted file mode 100644 index 1c1c2a2..0000000 --- a/Ix/Tests/AsyncTests.Conversions.cs +++ /dev/null @@ -1,312 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Threading; - -namespace Tests -{ - public partial class AsyncTests - { - [TestMethod] - public void ToAsyncEnumerable_Null() - { - AssertThrows(() => AsyncEnumerable.ToAsyncEnumerable(default(IEnumerable))); - AssertThrows(() => AsyncEnumerable.ToAsyncEnumerable(default(IObservable))); - } - - [TestMethod] - public void ToAsyncEnumerable1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void ToAsyncEnumerable2() - { - var ex = new Exception("Bang"); - var xs = ToAsyncEnumerable_Sequence(ex).ToAsyncEnumerable(); - var e = xs.GetEnumerator(); - HasNext(e, 42); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - } - - private IEnumerable ToAsyncEnumerable_Sequence(Exception e) - { - yield return 42; - throw e; - } - - [TestMethod] - public void ToAsyncEnumerable3() - { - var subscribed = false; - - var xs = new MyObservable(obs => - { - subscribed = true; - - obs.OnNext(42); - obs.OnCompleted(); - - return new MyDisposable(() => { }); - }).ToAsyncEnumerable(); - - Assert.IsFalse(subscribed); - - var e = xs.GetEnumerator(); - - Assert.IsTrue(subscribed); - - HasNext(e, 42); - NoNext(e); - } - - [TestMethod] - public void ToAsyncEnumerable4() - { - var ex = new Exception("Bang!"); - var subscribed = false; - - var xs = new MyObservable(obs => - { - subscribed = true; - - obs.OnError(ex); - - return new MyDisposable(() => { }); - }).ToAsyncEnumerable(); - - Assert.IsFalse(subscribed); - - var e = xs.GetEnumerator(); - - Assert.IsTrue(subscribed); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - } - - class MyObservable : IObservable - { - private Func, IDisposable> _subscribe; - - public MyObservable(Func, IDisposable> subscribe) - { - _subscribe = subscribe; - } - - public IDisposable Subscribe(IObserver observer) - { - return _subscribe(observer); - } - } - - class MyDisposable : IDisposable - { - private Action _dispose; - - public MyDisposable(Action dispose) - { - _dispose = dispose; - } - - public void Dispose() - { - _dispose(); - } - } - - [TestMethod] - public void ToEnumerable_Null() - { - AssertThrows(() => AsyncEnumerable.ToEnumerable(null)); - } - - [TestMethod] - public void ToEnumerable1() - { - var xs = AsyncEnumerable.Return(42).ToEnumerable(); - Assert.IsTrue(xs.SequenceEqual(new[] { 42 })); - } - - [TestMethod] - public void ToEnumerable2() - { - var xs = AsyncEnumerable.Empty().ToEnumerable(); - Assert.IsTrue(xs.SequenceEqual(new int[0])); - } - - [TestMethod] - public void ToEnumerable3() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex).ToEnumerable(); - AssertThrows(() => xs.GetEnumerator().MoveNext(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - } - -#if !NO_RXINTERFACES - [TestMethod] - public void ToObservable_Null() - { - AssertThrows(() => AsyncEnumerable.ToObservable(null)); - } - - [TestMethod] - public void ToObservable1() - { - var fail = false; - var evt = new ManualResetEvent(false); - - var xs = AsyncEnumerable.Empty().ToObservable(); - xs.Subscribe(new MyObserver( - x => - { - fail = true; - }, - ex => - { - fail = true; - evt.Set(); - }, - () => - { - evt.Set(); - } - )); - - evt.WaitOne(); - Assert.IsFalse(fail); - } - - [TestMethod] - public void ToObservable2() - { - var lst = new List(); - var fail = false; - var evt = new ManualResetEvent(false); - - var xs = AsyncEnumerable.Return(42).ToObservable(); - xs.Subscribe(new MyObserver( - x => - { - lst.Add(x); - }, - ex => - { - fail = true; - evt.Set(); - }, - () => - { - evt.Set(); - } - )); - - evt.WaitOne(); - Assert.IsFalse(fail); - Assert.IsTrue(lst.SequenceEqual(new[] { 42 })); - } - - [TestMethod] - public void ToObservable3() - { - var lst = new List(); - var fail = false; - var evt = new ManualResetEvent(false); - - var xs = AsyncEnumerable.Range(0, 10).ToObservable(); - xs.Subscribe(new MyObserver( - x => - { - lst.Add(x); - }, - ex => - { - fail = true; - evt.Set(); - }, - () => - { - evt.Set(); - } - )); - - evt.WaitOne(); - Assert.IsFalse(fail); - Assert.IsTrue(lst.SequenceEqual(Enumerable.Range(0, 10))); - } - - [TestMethod] - public void ToObservable4() - { - var ex1 = new Exception("Bang!"); - var ex_ = default(Exception); - var fail = false; - var evt = new ManualResetEvent(false); - - var xs = AsyncEnumerable.Throw(ex1).ToObservable(); - xs.Subscribe(new MyObserver( - x => - { - fail = true; - }, - ex => - { - ex_ = ex; - evt.Set(); - }, - () => - { - fail = true; - evt.Set(); - } - )); - - evt.WaitOne(); - Assert.IsFalse(fail); - Assert.AreEqual(ex1, ((AggregateException)ex_).InnerExceptions.Single()); - } - - class MyObserver : IObserver - { - private Action _onNext; - private Action _onError; - private Action _onCompleted; - - public MyObserver(Action onNext, Action onError, Action onCompleted) - { - _onNext = onNext; - _onError = onError; - _onCompleted = onCompleted; - } - - public void OnCompleted() - { - _onCompleted(); - } - - public void OnError(Exception error) - { - _onError(error); - } - - public void OnNext(T value) - { - _onNext(value); - } - } -#endif - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Creation.cs b/Ix/Tests/AsyncTests.Creation.cs deleted file mode 100644 index 32e849a..0000000 --- a/Ix/Tests/AsyncTests.Creation.cs +++ /dev/null @@ -1,409 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Threading.Tasks; -using System.Threading; - -namespace Tests -{ - static class Ext - { - public static Task MoveNext(this IAsyncEnumerator enumerator) - { - return enumerator.MoveNext(CancellationToken.None); - } - } - - public partial class AsyncTests - { - [TestMethod] - public void Return() - { - var xs = AsyncEnumerable.Return(42); - HasNext(xs.GetEnumerator(), 42); - } - - [TestMethod] - public void Never() - { - var xs = AsyncEnumerable.Never(); - - var e = xs.GetEnumerator(); - Assert.IsFalse(e.MoveNext().IsCompleted); // Very rudimentary check - AssertThrows(() => Nop(e.Current)); - e.Dispose(); - } - - [TestMethod] - public void Empty1() - { - var xs = AsyncEnumerable.Empty(); - NoNext(xs.GetEnumerator()); - } - - [TestMethod] - public void Empty2() - { - var xs = AsyncEnumerable.Empty(); - - var e = xs.GetEnumerator(); - Assert.IsFalse(e.MoveNext().Result); - AssertThrows(() => Nop(e.Current)); - } - - [TestMethod] - public void Throw_Null() - { - AssertThrows(() => AsyncEnumerable.Throw(null)); - } - - [TestMethod] - public void Throw() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - AssertThrows(() => Nop(e.Current)); - } - - private void Nop(object o) - { - } - - [TestMethod] - public void Range_Null() - { - AssertThrows(() => AsyncEnumerable.Range(0, -1)); - } - - [TestMethod] - public void Range1() - { - var xs = AsyncEnumerable.Range(2, 5); - - var e = xs.GetEnumerator(); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Range2() - { - var xs = AsyncEnumerable.Range(2, 0); - - var e = xs.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Repeat_Null() - { - AssertThrows(() => AsyncEnumerable.Repeat(0, -1)); - } - - [TestMethod] - public void Repeat1() - { - var xs = AsyncEnumerable.Repeat(2, 5); - - var e = xs.GetEnumerator(); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void Repeat2() - { - var xs = AsyncEnumerable.Repeat(2, 0); - - var e = xs.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Repeat3() - { - var xs = AsyncEnumerable.Repeat(2); - - var e = xs.GetEnumerator(); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 2); - e.Dispose(); - } - - [TestMethod] - public void Defer_Null() - { - AssertThrows(() => AsyncEnumerable.Defer(null)); - } - - [TestMethod] - public void Defer1() - { - var x = 0; - var xs = AsyncEnumerable.Defer(() => new[] { x }.ToAsyncEnumerable()); - - { - var e = xs.GetEnumerator(); - HasNext(e, 0); - NoNext(e); - } - - { - x++; - var e = xs.GetEnumerator(); - HasNext(e, 1); - NoNext(e); - } - } - - [TestMethod] - public void Generate_Null() - { - AssertThrows(() => AsyncEnumerable.Generate(0, null, x => x, x => x)); - AssertThrows(() => AsyncEnumerable.Generate(0, x => true, null, x => x)); - AssertThrows(() => AsyncEnumerable.Generate(0, x => true, x => x, null)); - } - - [TestMethod] - public void Generate1() - { - var xs = AsyncEnumerable.Generate(0, x => x < 5, x => x + 1, x => x * x); - - var e = xs.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 1); - HasNext(e, 4); - HasNext(e, 9); - HasNext(e, 16); - NoNext(e); - e.Dispose(); - } - - [TestMethod] - public void Generate2() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Generate(0, x => { throw ex; }, x => x + 1, x => x * x); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Generate3() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Generate(0, x => true, x => x + 1, x => { if (x == 1) throw ex; return x * x; }); - - var e = xs.GetEnumerator(); - HasNext(e, 0); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Generate4() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Generate(0, x => true, x => { throw ex; }, x => x * x); - - var e = xs.GetEnumerator(); - HasNext(e, 0); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Using_Null() - { - AssertThrows(() => AsyncEnumerable.Using(null, _ => null)); - AssertThrows(() => AsyncEnumerable.Using(() => new MyD(null), null)); - } - - [TestMethod] - public void Using1() - { - var i = 0; - var d = 0; - - var xs = AsyncEnumerable.Using( - () => - { - i++; - return new MyD(() => { d++; }); - }, - _ => AsyncEnumerable.Return(42) - ); - - Assert.AreEqual(0, i); - - var e = xs.GetEnumerator(); - Assert.AreEqual(1, i); - } - - [TestMethod] - public void Using2() - { - var i = 0; - var d = 0; - - var xs = AsyncEnumerable.Using( - () => - { - i++; - return new MyD(() => { d++; }); - }, - _ => AsyncEnumerable.Return(42) - ); - - Assert.AreEqual(0, i); - - var e = xs.GetEnumerator(); - Assert.AreEqual(1, i); - - e.Dispose(); - Assert.AreEqual(1, d); - } - - [TestMethod] - public void Using3() - { - var ex = new Exception("Bang!"); - var i = 0; - var d = 0; - - var xs = AsyncEnumerable.Using( - () => - { - i++; - return new MyD(() => { d++; }); - }, - _ => { throw ex; } - ); - - Assert.AreEqual(0, i); - - AssertThrows(() => xs.GetEnumerator(), ex_ => ex_ == ex); - - Assert.AreEqual(1, d); - } - - [TestMethod] - public void Using4() - { - var i = 0; - var disposed = false; - - var xs = AsyncEnumerable.Using( - () => - { - i++; - return new MyD(() => { disposed = true; }); - }, - _ => AsyncEnumerable.Return(42) - ); - - Assert.AreEqual(0, i); - - var e = xs.GetEnumerator(); - Assert.AreEqual(1, i); - - HasNext(e, 42); - NoNext(e); - - Assert.IsTrue(disposed); - } - - [TestMethod] - public void Using5() - { - var ex = new Exception("Bang!"); - var i = 0; - var disposed = false; - - var xs = AsyncEnumerable.Using( - () => - { - i++; - return new MyD(() => { disposed = true; }); - }, - _ => AsyncEnumerable.Throw(ex) - ); - - Assert.AreEqual(0, i); - - var e = xs.GetEnumerator(); - Assert.AreEqual(1, i); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - - Assert.IsTrue(disposed); - } - - [TestMethod] - public void Using6() - { - var i = 0; - var disposed = false; - - var xs = AsyncEnumerable.Using( - () => - { - i++; - return new MyD(() => { disposed = true; }); - }, - _ => AsyncEnumerable.Range(0, 10) - ); - - Assert.AreEqual(0, i); - - var e = xs.GetEnumerator(); - Assert.AreEqual(1, i); - - HasNext(e, 0); - HasNext(e, 1); - - var cts = new CancellationTokenSource(); - var t = e.MoveNext(cts.Token); - cts.Cancel(); - - t.Wait(); - - Assert.IsTrue(disposed); - } - - class MyD : IDisposable - { - private readonly Action _dispose; - - public MyD(Action dispose) - { - _dispose = dispose; - } - - public void Dispose() - { - _dispose(); - } - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Exceptions.cs b/Ix/Tests/AsyncTests.Exceptions.cs deleted file mode 100644 index f7c8a8f..0000000 --- a/Ix/Tests/AsyncTests.Exceptions.cs +++ /dev/null @@ -1,551 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Threading; - -namespace Tests -{ - public partial class AsyncTests - { - [TestMethod] - public void Catch_Null() - { - AssertThrows(() => AsyncEnumerable.Catch(default(IAsyncEnumerable), x => null)); - AssertThrows(() => AsyncEnumerable.Catch(AsyncEnumerable.Return(42), default(Func>))); - - AssertThrows(() => AsyncEnumerable.Catch(default(IAsyncEnumerable), AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.Catch(AsyncEnumerable.Return(42), default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Catch(default(IAsyncEnumerable[]))); - AssertThrows(() => AsyncEnumerable.Catch(default(IEnumerable>))); - } - - [TestMethod] - public void Catch1() - { - var err = false; - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = xs.Catch(ex_ => { err = true; return ys; }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - NoNext(e); - - Assert.IsFalse(err); - } - - [TestMethod] - public void Catch2() - { - var ex = new InvalidOperationException("Bang!"); - - var err = false; - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = xs.Catch(ex_ => { err = true; return ys; }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - Assert.IsFalse(err); - - HasNext(e, 4); - - Assert.IsTrue(err); - - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Catch3() - { - var ex = new InvalidOperationException("Bang!"); - - var err = false; - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = xs.Catch(ex_ => { err = true; return ys; }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - Assert.IsFalse(err); - - HasNext(e, 4); - - Assert.IsTrue(err); - - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Catch4() - { - var ex = new DivideByZeroException(); - - var err = false; - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = xs.Catch(ex_ => { err = true; return ys; }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - - Assert.IsFalse(err); - } - - [TestMethod] - public void Catch5() - { - var ex = new InvalidOperationException("Bang!"); - var ex2 = new Exception("Oops!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = xs.Catch(ex_ => { if (ex_.Message == "Bang!") throw ex2; return ys; }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex2); - } - - [TestMethod] - public void Catch6() - { - var ex = new InvalidOperationException("Bang!"); - - var err = false; - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - - var res = xs.Catch(ex_ => { err = true; return xs; }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - Assert.IsFalse(err); - - HasNext(e, 1); - - Assert.IsTrue(err); - - HasNext(e, 2); - HasNext(e, 3); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Catch7() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.Catch(xs, ys); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - NoNext(e); - } - - [TestMethod] - public void Catch8() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.Catch(xs, ys); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Catch9() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.Catch(new[] { xs, xs, ys, ys }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Catch10() - { - var res = CatchXss().Catch(); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - } - - private IEnumerable> CatchXss() - { - yield return new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(new Exception("!!!"))); - throw new Exception("Bang!"); - } - - [TestMethod] - public void Catch11() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - - var res = AsyncEnumerable.Catch(new[] { xs, xs }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Catch12() - { - var res = AsyncEnumerable.Catch(Enumerable.Empty>()); - - var e = res.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Finally_Null() - { - AssertThrows(() => AsyncEnumerable.Finally(default(IAsyncEnumerable), () => { })); - AssertThrows(() => AsyncEnumerable.Finally(AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Finally1() - { - var b = false; - - var xs = AsyncEnumerable.Empty().Finally(() => { b = true; }); - - var e = xs.GetEnumerator(); - - Assert.IsFalse(b); - NoNext(e); - - Assert.IsTrue(b); - } - - [TestMethod] - public void Finally2() - { - var b = false; - - var xs = AsyncEnumerable.Return(42).Finally(() => { b = true; }); - - var e = xs.GetEnumerator(); - - Assert.IsFalse(b); - HasNext(e, 42); - - Assert.IsFalse(b); - NoNext(e); - - Assert.IsTrue(b); - } - - [TestMethod] - public void Finally3() - { - var ex = new Exception("Bang!"); - - var b = false; - - var xs = AsyncEnumerable.Throw(ex).Finally(() => { b = true; }); - - var e = xs.GetEnumerator(); - - Assert.IsFalse(b); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - - Assert.IsTrue(b); - } - - [TestMethod] - public void Finally4() - { - var b = false; - - var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { b = true; }); - - var e = xs.GetEnumerator(); - - Assert.IsFalse(b); - HasNext(e, 1); - - Assert.IsFalse(b); - HasNext(e, 2); - - Assert.IsFalse(b); - NoNext(e); - - Assert.IsTrue(b); - } - - [TestMethod] - public void Finally5() - { - var b = false; - - var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { b = true; }); - - var e = xs.GetEnumerator(); - - Assert.IsFalse(b); - HasNext(e, 1); - - e.Dispose(); - - Assert.IsTrue(b); - } - - [TestMethod] - public void Finally6() - { - var b = false; - - var xs = new[] { 1, 2 }.ToAsyncEnumerable().Finally(() => { b = true; }); - - var e = xs.GetEnumerator(); - - var cts = new CancellationTokenSource(); - - var t = e.MoveNext(cts.Token); - cts.Cancel(); - t.Wait(); - - Assert.IsTrue(b); - } - - [TestMethod] - public void OnErrorResumeNext_Null() - { - AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(default(IAsyncEnumerable), AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(AsyncEnumerable.Return(42), default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(default(IAsyncEnumerable[]))); - AssertThrows(() => AsyncEnumerable.OnErrorResumeNext(default(IEnumerable>))); - } - - [TestMethod] - public void OnErrorResumeNext7() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.OnErrorResumeNext(xs, ys); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void OnErrorResumeNext8() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.OnErrorResumeNext(xs, ys); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void OnErrorResumeNext9() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.OnErrorResumeNext(new[] { xs, xs, ys, ys }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void OnErrorResumeNext10() - { - var res = OnErrorResumeNextXss().OnErrorResumeNext(); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - } - - private IEnumerable> OnErrorResumeNextXss() - { - yield return new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(new Exception("!!!"))); - throw new Exception("Bang!"); - } - - [TestMethod] - public void OnErrorResumeNext11() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - - var res = AsyncEnumerable.OnErrorResumeNext(new[] { xs, xs }); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - NoNext(e); - } - - [TestMethod] - public void OnErrorResumeNext12() - { - var res = AsyncEnumerable.OnErrorResumeNext(Enumerable.Empty>()); - - var e = res.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Retry_Null() - { - AssertThrows(() => AsyncEnumerable.Retry(default(IAsyncEnumerable))); - - AssertThrows(() => AsyncEnumerable.Retry(default(IAsyncEnumerable), 1)); - AssertThrows(() => AsyncEnumerable.Retry(AsyncEnumerable.Return(42), -1)); - } - - [TestMethod] - public void Retry1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - - var res = xs.Retry(); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - NoNext(e); - } - - [TestMethod] - public void Retry2() - { - var ex = new InvalidOperationException("Bang!"); - - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - - var res = xs.Retry(); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Multiple.cs b/Ix/Tests/AsyncTests.Multiple.cs deleted file mode 100644 index 1ddd56f..0000000 --- a/Ix/Tests/AsyncTests.Multiple.cs +++ /dev/null @@ -1,787 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Threading; - -namespace Tests -{ - public partial class AsyncTests - { - [TestMethod] - public void Concat_Null() - { - AssertThrows(() => AsyncEnumerable.Concat(null, AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.Concat(AsyncEnumerable.Return(42), null)); - AssertThrows(() => AsyncEnumerable.Concat(default(IAsyncEnumerable[]))); - AssertThrows(() => AsyncEnumerable.Concat(default(IEnumerable>))); - } - - [TestMethod] - public void Concat1() - { - var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable()); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Concat2() - { - var ex = new Exception("Bang"); - var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw(ex)); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Concat3() - { - var ex = new Exception("Bang"); - var ys = AsyncEnumerable.Throw(ex).Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable()); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Concat4() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5 }.ToAsyncEnumerable(); - var zs = new[] { 6, 7, 8 }.ToAsyncEnumerable(); - - var res = AsyncEnumerable.Concat(xs, ys, zs); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - HasNext(e, 7); - HasNext(e, 8); - NoNext(e); - } - - [TestMethod] - public void Concat5() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5 }.ToAsyncEnumerable(); - var zs = AsyncEnumerable.Throw(ex); - - var res = AsyncEnumerable.Concat(xs, ys, zs); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Concat6() - { - var res = AsyncEnumerable.Concat(ConcatXss()); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - } - - static IEnumerable> ConcatXss() - { - yield return new[] { 1, 2, 3 }.ToAsyncEnumerable(); - yield return new[] { 4, 5 }.ToAsyncEnumerable(); - throw new Exception("Bang!"); - } - - [TestMethod] - public void Zip_Null() - { - AssertThrows(() => AsyncEnumerable.Zip(null, AsyncEnumerable.Return(42), (x, y) => x + y)); - AssertThrows(() => AsyncEnumerable.Zip(AsyncEnumerable.Return(42), null, (x, y) => x + y)); - AssertThrows(() => AsyncEnumerable.Zip(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Zip1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - var res = xs.Zip(ys, (x, y) => x * y); - - var e = res.GetEnumerator(); - HasNext(e, 1 * 4); - HasNext(e, 2 * 5); - HasNext(e, 3 * 6); - NoNext(e); - } - - [TestMethod] - public void Zip2() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5, 6, 7 }.ToAsyncEnumerable(); - var res = xs.Zip(ys, (x, y) => x * y); - - var e = res.GetEnumerator(); - HasNext(e, 1 * 4); - HasNext(e, 2 * 5); - HasNext(e, 3 * 6); - NoNext(e); - } - - [TestMethod] - public void Zip3() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable(); - var res = xs.Zip(ys, (x, y) => x * y); - - var e = res.GetEnumerator(); - HasNext(e, 1 * 4); - HasNext(e, 2 * 5); - HasNext(e, 3 * 6); - NoNext(e); - } - - [TestMethod] - public void Zip4() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = AsyncEnumerable.Throw(ex); - var res = xs.Zip(ys, (x, y) => x * y); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Zip5() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.Zip(ys, (x, y) => x * y); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Zip6() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.Zip(ys, (x, y) => { if (x > 0) throw ex; return x * y; }); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Union_Null() - { - AssertThrows(() => AsyncEnumerable.Union(null, AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.Union(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Union(null, AsyncEnumerable.Return(42), new Eq())); - AssertThrows(() => AsyncEnumerable.Union(AsyncEnumerable.Return(42), null, new Eq())); - AssertThrows(() => AsyncEnumerable.Union(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Union1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); - var res = xs.Union(ys); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 5); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Union2() - { - var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable(); - var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable(); - var res = xs.Union(ys, new Eq()); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, -3); - HasNext(e, 5); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Intersect_Null() - { - AssertThrows(() => AsyncEnumerable.Intersect(null, AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.Intersect(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Intersect(null, AsyncEnumerable.Return(42), new Eq())); - AssertThrows(() => AsyncEnumerable.Intersect(AsyncEnumerable.Return(42), null, new Eq())); - AssertThrows(() => AsyncEnumerable.Intersect(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Intersect1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); - var res = xs.Intersect(ys); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 3); - NoNext(e); - } - - [TestMethod] - public void Intersect2() - { - var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable(); - var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable(); - var res = xs.Intersect(ys, new Eq()); - - var e = res.GetEnumerator(); - HasNext(e, 1); - HasNext(e, -3); - NoNext(e); - } - - [TestMethod] - public void Except_Null() - { - AssertThrows(() => AsyncEnumerable.Except(null, AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.Except(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Except(null, AsyncEnumerable.Return(42), new Eq())); - AssertThrows(() => AsyncEnumerable.Except(AsyncEnumerable.Return(42), null, new Eq())); - AssertThrows(() => AsyncEnumerable.Except(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Except1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); - var res = xs.Except(ys); - - var e = res.GetEnumerator(); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void Except2() - { - var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable(); - var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable(); - var res = xs.Except(ys, new Eq()); - - var e = res.GetEnumerator(); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void SequenceEqual_Null() - { - AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42), new Eq())); - AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null, new Eq())); - AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null, CancellationToken.None)); - - AssertThrows(() => AsyncEnumerable.SequenceEqual(null, AsyncEnumerable.Return(42), new Eq(), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), null, new Eq(), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.SequenceEqual(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None)); - } - - [TestMethod] - public void SequenceEqual1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(xs); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void SequenceEqual2() - { - var xs = AsyncEnumerable.Empty(); - var res = xs.SequenceEqual(xs); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void SequenceEqual3() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void SequenceEqual4() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void SequenceEqual5() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void SequenceEqual6() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = AsyncEnumerable.Throw(ex); - var res = xs.SequenceEqual(ys); - - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SequenceEqual7() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys); - - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SequenceEqual8() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(xs, new Eq()); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void SequenceEqual9() - { - var xs = AsyncEnumerable.Empty(); - var res = xs.SequenceEqual(xs, new Eq()); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void SequenceEqual10() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys, new Eq()); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void SequenceEqual11() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys, new Eq()); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void SequenceEqual12() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys, new Eq()); - Assert.IsFalse(res.Result); - } - - [TestMethod] - public void SequenceEqual13() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = AsyncEnumerable.Throw(ex); - var res = xs.SequenceEqual(ys, new Eq()); - - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SequenceEqual14() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys, new Eq()); - - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SequenceEqual15() - { - var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable(); - var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys, new Eq()); - Assert.IsTrue(res.Result); - } - - [TestMethod] - public void SequenceEqual16() - { - var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable(); - var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable(); - var res = xs.SequenceEqual(ys, new EqEx()); - AssertThrows(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException); - } - - class EqEx : IEqualityComparer - { - public bool Equals(int x, int y) - { - throw new NotImplementedException(); - } - - public int GetHashCode(int obj) - { - throw new NotImplementedException(); - } - } - - [TestMethod] - public void GroupJoin_Null() - { - AssertThrows(() => AsyncEnumerable.GroupJoin(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null)); - - AssertThrows(() => AsyncEnumerable.GroupJoin(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupJoin(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer))); - } - - [TestMethod] - public void GroupJoin1() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 4, 7, 6, 2, 3, 4, 8, 9 }.ToAsyncEnumerable(); - - var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); - - var e = res.GetEnumerator(); - HasNext(e, "0 - 639"); - HasNext(e, "1 - 474"); - HasNext(e, "2 - 28"); - NoNext(e); - } - - [TestMethod] - public void GroupJoin2() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - - var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); - - var e = res.GetEnumerator(); - HasNext(e, "0 - 36"); - HasNext(e, "1 - 4"); - HasNext(e, "2 - "); - NoNext(e); - } - - [TestMethod] - public void GroupJoin3() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - - var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupJoin4() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = AsyncEnumerable.Throw(ex); - - var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupJoin5() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - - var res = xs.GroupJoin(ys, x => { throw ex; }, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupJoin6() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - - var res = xs.GroupJoin(ys, x => x % 3, y => { throw ex; }, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupJoin7() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - - var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => { - if (x == 1) - throw ex; - return x + " - " + i.Aggregate("", (s, j) => s + j).Result; - }); - - var e = res.GetEnumerator(); - HasNext(e, "0 - 36"); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Join_Null() - { - AssertThrows(() => AsyncEnumerable.Join(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null)); - - AssertThrows(() => AsyncEnumerable.Join(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Join(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer))); - } - - [TestMethod] - public void Join1() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); - - var e = res.GetEnumerator(); - HasNext(e, 0 + 3); - HasNext(e, 0 + 6); - HasNext(e, 1 + 4); - NoNext(e); - } - - [TestMethod] - public void Join2() - { - var xs = new[] { 3, 6, 4 }.ToAsyncEnumerable(); - var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); - - var e = res.GetEnumerator(); - HasNext(e, 3 + 0); - HasNext(e, 6 + 0); - HasNext(e, 4 + 1); - NoNext(e); - } - - [TestMethod] - public void Join3() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 6 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); - - var e = res.GetEnumerator(); - HasNext(e, 0 + 3); - HasNext(e, 0 + 6); - NoNext(e); - } - - [TestMethod] - public void Join4() - { - var xs = new[] { 3, 6 }.ToAsyncEnumerable(); - var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); - - var e = res.GetEnumerator(); - HasNext(e, 3 + 0); - HasNext(e, 6 + 0); - NoNext(e); - } - - [TestMethod] - public void Join5() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Join6() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = AsyncEnumerable.Throw(ex); - - var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Join7() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => { throw ex; }, y => y, (x, y) => x + y); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Join8() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x, y => { throw ex; }, (x, y) => x + y); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Join9() - { - var ex = new Exception("Bang!"); - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - - var res = xs.Join(ys, x => x, y => y, (x, y) => { throw ex; }); - - var e = res.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectManyMultiple_Null() - { - AssertThrows(() => AsyncEnumerable.SelectMany(default(IAsyncEnumerable), AsyncEnumerable.Return(42))); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(IAsyncEnumerable))); - } - - [TestMethod] - public void SelectManyMultiple1() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = new[] { 3, 4 }.ToAsyncEnumerable(); - - var res = xs.SelectMany(ys); - - var e = res.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.Single.cs b/Ix/Tests/AsyncTests.Single.cs deleted file mode 100644 index 409f48a..0000000 --- a/Ix/Tests/AsyncTests.Single.cs +++ /dev/null @@ -1,2455 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Threading; - -namespace Tests -{ - public partial class AsyncTests - { - [TestMethod] - public void Select_Null() - { - AssertThrows(() => AsyncEnumerable.Select(null, x => x)); - AssertThrows(() => AsyncEnumerable.Select(null, (x, i) => x)); - AssertThrows(() => AsyncEnumerable.Select(AsyncEnumerable.Return(42), default(Func))); - AssertThrows(() => AsyncEnumerable.Select(AsyncEnumerable.Return(42), default(Func))); - } - - [TestMethod] - public void Select1() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = xs.Select(x => (char)('a' + x)); - - var e = ys.GetEnumerator(); - HasNext(e, 'a'); - HasNext(e, 'b'); - HasNext(e, 'c'); - NoNext(e); - } - - [TestMethod] - public void Select2() - { - var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable(); - var ys = xs.Select((x, i) => (char)('a' + i)); - - var e = ys.GetEnumerator(); - HasNext(e, 'a'); - HasNext(e, 'b'); - HasNext(e, 'c'); - NoNext(e); - } - - [TestMethod] - public void Select3() - { - var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable(); - var ys = xs.Select(x => 1 / x); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException); - } - - [TestMethod] - public void Select4() - { - var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable(); - var ys = xs.Select((x, i) => 1 / i); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException); - } - - [TestMethod] - public void Where_Null() - { - AssertThrows(() => AsyncEnumerable.Where(null, x => true)); - AssertThrows(() => AsyncEnumerable.Where(null, (x, i) => true)); - AssertThrows(() => AsyncEnumerable.Where(AsyncEnumerable.Return(42), default(Func))); - AssertThrows(() => AsyncEnumerable.Where(AsyncEnumerable.Return(42), default(Func))); - } - - [TestMethod] - public void Where1() - { - var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); - var ys = xs.Where(x => x % 2 == 0); - var e = ys.GetEnumerator(); - HasNext(e, 8); - HasNext(e, 4); - HasNext(e, 6); - HasNext(e, 2); - HasNext(e, 0); - NoNext(e); - } - - [TestMethod] - public void Where2() - { - var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); - var ys = xs.Where((x, i) => i % 2 == 0); - - var e = ys.GetEnumerator(); - HasNext(e, 8); - HasNext(e, 7); - HasNext(e, 6); - HasNext(e, 2); - HasNext(e, 0); - NoNext(e); - } - - [TestMethod] - public void Where3() - { - var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); - var ex = new Exception("Bang"); - var ys = xs.Where(x => { if (x == 4) throw ex; return true; }); - - var e = ys.GetEnumerator(); - HasNext(e, 8); - HasNext(e, 5); - HasNext(e, 7); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Where4() - { - var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable(); - var ex = new Exception("Bang"); - var ys = xs.Where((x, i) => { if (i == 3) throw ex; return true; }); - - var e = ys.GetEnumerator(); - HasNext(e, 8); - HasNext(e, 5); - HasNext(e, 7); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Where5() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Where(x => true); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Where6() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - - var ys = xs.Where((x, i) => true); - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany_Null() - { - AssertThrows(() => AsyncEnumerable.SelectMany(null, x => null)); - AssertThrows(() => AsyncEnumerable.SelectMany(null, (x, i) => null)); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>))); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>))); - - AssertThrows(() => AsyncEnumerable.SelectMany(null, x => null, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.SelectMany(null, (x, i) => null, (x, y) => x)); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>), (x, y) => x)); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), default(Func>), (x, y) => x)); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), x => null, default(Func))); - AssertThrows(() => AsyncEnumerable.SelectMany(AsyncEnumerable.Return(42), (x, i) => null, default(Func))); - } - - [TestMethod] - public void SelectMany1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable()); - - var e = ys.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 0); - HasNext(e, 1); - HasNext(e, 0); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void SelectMany2() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany(x => - { - if (x < 3) - return Enumerable.Range(0, x).ToAsyncEnumerable(); - else - return AsyncEnumerable.Throw(ex); - }); - - var e = ys.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 0); - HasNext(e, 1); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany3() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable()); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany4() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany(x => - { - if (x < 3) - return Enumerable.Range(0, x).ToAsyncEnumerable(); - else - throw ex; - }); - - var e = ys.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 0); - HasNext(e, 1); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany5() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 5, x).ToAsyncEnumerable()); - - var e = ys.GetEnumerator(); - HasNext(e, 5); - HasNext(e, 6); - HasNext(e, 7); - HasNext(e, 7); - HasNext(e, 8); - HasNext(e, 9); - NoNext(e); - } - - [TestMethod] - public void SelectMany6() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany((x, i) => - { - if (i < 2) - return Enumerable.Range(0, x).ToAsyncEnumerable(); - else - return AsyncEnumerable.Throw(ex); - }); - - var e = ys.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 0); - HasNext(e, 1); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany7() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.SelectMany((x, i) => Enumerable.Range(0, x).ToAsyncEnumerable()); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany8() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany((x, i) => - { - if (i < 2) - return Enumerable.Range(0, x).ToAsyncEnumerable(); - else - throw ex; - }); - - var e = ys.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 0); - HasNext(e, 1); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany9() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => x * y); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 6); - HasNext(e, 8); - HasNext(e, 9); - HasNext(e, 12); - HasNext(e, 15); - NoNext(e); - } - - [TestMethod] - public void SelectMany10() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => x * y); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 8); - HasNext(e, 10); - HasNext(e, 15); - HasNext(e, 18); - HasNext(e, 21); - NoNext(e); - } - - [TestMethod] - public void SelectMany11() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => - { - if (x * y > 10) - throw ex; - return x * y; - }); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 6); - HasNext(e, 8); - HasNext(e, 9); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SelectMany12() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => - { - if (x * y > 10) - throw ex; - return x * y; - }); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 8); - HasNext(e, 10); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void OfType_Null() - { - AssertThrows(() => AsyncEnumerable.OfType(null)); - } - - [TestMethod] - public void OfType() - { - var xs = new object[] { 1, 1.2, true, 4, "" }.ToAsyncEnumerable(); - var ys = xs.OfType(); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Cast_Null() - { - AssertThrows(() => AsyncEnumerable.Cast(null)); - } - - [TestMethod] - public void Cast() - { - var xs = new object[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Cast(); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Do_Null() - { - AssertThrows(() => AsyncEnumerable.Do(null, x => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action))); - - AssertThrows(() => AsyncEnumerable.Do(null, x => { }, () => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action), () => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, default(Action))); - - AssertThrows(() => AsyncEnumerable.Do(null, x => { }, ex => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action), ex => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, default(Action))); - - AssertThrows(() => AsyncEnumerable.Do(null, x => { }, ex => { }, () => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(Action), ex => { }, () => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, default(Action), () => { })); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), x => { }, ex => { }, default(Action))); - - AssertThrows(() => AsyncEnumerable.Do(null, new MyObs())); - AssertThrows(() => AsyncEnumerable.Do(AsyncEnumerable.Return(42), default(IObserver))); - } - - class MyObs : IObserver - { - public void OnCompleted() - { - throw new NotImplementedException(); - } - - public void OnError(Exception error) - { - throw new NotImplementedException(); - } - - public void OnNext(int value) - { - throw new NotImplementedException(); - } - } - - [TestMethod] - public void Do1() - { - var sum = 0; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Do(x => sum += x); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - Assert.AreEqual(1, sum); - HasNext(e, 2); - Assert.AreEqual(3, sum); - HasNext(e, 3); - Assert.AreEqual(6, sum); - HasNext(e, 4); - Assert.AreEqual(10, sum); - NoNext(e); - } - - [TestMethod] - public void Do2() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Do(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Do3() - { - var sum = 0; - var fail = false; - var done = false; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Do(x => sum += x, ex => { fail = true; }, () => { done = true; }); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - Assert.AreEqual(1, sum); - HasNext(e, 2); - Assert.AreEqual(3, sum); - HasNext(e, 3); - Assert.AreEqual(6, sum); - HasNext(e, 4); - Assert.AreEqual(10, sum); - NoNext(e); - - Assert.IsFalse(fail); - Assert.IsTrue(done); - } - - [TestMethod] - public void Do4() - { - var sum = 0; - var done = false; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Do(x => sum += x, () => { done = true; }); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - Assert.AreEqual(1, sum); - HasNext(e, 2); - Assert.AreEqual(3, sum); - HasNext(e, 3); - Assert.AreEqual(6, sum); - HasNext(e, 4); - Assert.AreEqual(10, sum); - NoNext(e); - - Assert.IsTrue(done); - } - - [TestMethod] - public void Do5() - { - var ex = new Exception("Bang"); - var exa = default(Exception); - var done = false; - var hasv = false; - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; }, () => { done = true; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - - Assert.IsFalse(hasv); - Assert.IsFalse(done); - Assert.AreSame(((AggregateException)exa).Flatten().InnerExceptions.Single(), ex); - } - - [TestMethod] - public void Do6() - { - var ex = new Exception("Bang"); - var exa = default(Exception); - var hasv = false; - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - - Assert.IsFalse(hasv); - Assert.AreSame(((AggregateException)exa).Flatten().InnerExceptions.Single(), ex); - } - - [TestMethod] - public void ForEachAsync_Null() - { - AssertThrows(() => AsyncEnumerable.ForEachAsync(null, x => { })); - AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action))); - AssertThrows(() => AsyncEnumerable.ForEachAsync(null, (x, i) => { })); - AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action))); - - AssertThrows(() => AsyncEnumerable.ForEachAsync(null, x => { }, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ForEachAsync(null, (x, i) => { }, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ForEachAsync(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); - } - - [TestMethod] - public void ForEach_Null() - { - AssertThrows(() => AsyncEnumerable.ForEach(null, x => { })); - AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action))); - AssertThrows(() => AsyncEnumerable.ForEach(null, (x, i) => { })); - AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action))); - - AssertThrows(() => AsyncEnumerable.ForEach(null, x => { }, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ForEach(null, (x, i) => { }, CancellationToken.None)); - AssertThrows(() => AsyncEnumerable.ForEach(AsyncEnumerable.Return(42), default(Action), CancellationToken.None)); - } - - [TestMethod] - public void ForEachAsync1() - { - var sum = 0; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - xs.ForEachAsync(x => sum += x).Wait(); - Assert.AreEqual(10, sum); - } - - [TestMethod] - public void ForEach1() - { - var sum = 0; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - xs.ForEach(x => sum += x); - Assert.AreEqual(10, sum); - } - - [TestMethod] - public void ForEachAsync2() - { - var sum = 0; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - xs.ForEach((x, i) => sum += x * i); - Assert.AreEqual(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum); - } - - [TestMethod] - public void ForEach2() - { - var sum = 0; - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - xs.ForEachAsync((x, i) => sum += x * i).Wait(); - Assert.AreEqual(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum); - } - - [TestMethod] - public void ForEachAsync3() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - AssertThrows(() => xs.ForEachAsync(x => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEach3() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - AssertThrows(() => xs.ForEach(x => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEachAsync4() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - AssertThrows(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEach4() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - - AssertThrows(() => xs.ForEach((x, i) => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEachAsync5() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - - AssertThrows(() => xs.ForEachAsync(x => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEach5() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - - AssertThrows(() => xs.ForEach(x => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEachAsync6() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - - AssertThrows(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ForEach6() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - - AssertThrows(() => xs.ForEach((x, i) => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Take_Null() - { - AssertThrows(() => AsyncEnumerable.Take(null, 5)); - AssertThrows(() => AsyncEnumerable.Take(AsyncEnumerable.Return(42), -1)); - } - - [TestMethod] - public void Take1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Take(2); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void Take2() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Take(10); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Take3() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Take(0); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Take4() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Take(2); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void TakeWhile_Null() - { - AssertThrows(() => AsyncEnumerable.TakeWhile(null, x => true)); - AssertThrows(() => AsyncEnumerable.TakeWhile(null, (x, i) => true)); - AssertThrows(() => AsyncEnumerable.TakeWhile(AsyncEnumerable.Return(42), default(Func))); - AssertThrows(() => AsyncEnumerable.TakeWhile(AsyncEnumerable.Return(42), default(Func))); - } - - [TestMethod] - public void TakeWhile1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile(x => x < 3); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void TakeWhile2() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile(x => false); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void TakeWhile3() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile(x => true); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void TakeWhile4() - { - var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile(x => x < 3); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void TakeWhile5() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void TakeWhile6() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile((x, i) => i < 2); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void TakeWhile7() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile((x, i) => false); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void TakeWhile8() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile((x, i) => true); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void TakeWhile9() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.TakeWhile((x, i) => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Skip_Null() - { - AssertThrows(() => AsyncEnumerable.Skip(null, 5)); - AssertThrows(() => AsyncEnumerable.Skip(AsyncEnumerable.Return(42), -1)); - } - - [TestMethod] - public void Skip1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Skip(2); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Skip2() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Skip(10); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Skip3() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.Skip(0); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Skip4() - { - var ex = new Exception("Bang"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Skip(2); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SkipWhile_Null() - { - AssertThrows(() => AsyncEnumerable.SkipWhile(null, x => true)); - AssertThrows(() => AsyncEnumerable.SkipWhile(null, (x, i) => true)); - AssertThrows(() => AsyncEnumerable.SkipWhile(AsyncEnumerable.Return(42), default(Func))); - AssertThrows(() => AsyncEnumerable.SkipWhile(AsyncEnumerable.Return(42), default(Func))); - } - - [TestMethod] - public void SkipWhile1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile(x => x < 3); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void SkipWhile2() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile(x => false); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void SkipWhile3() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile(x => true); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void SkipWhile4() - { - var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile(x => x < 3); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 3); - HasNext(e, 2); - HasNext(e, 1); - NoNext(e); - } - - [TestMethod] - public void SkipWhile5() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void SkipWhile6() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile((x, i) => i < 2); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void SkipWhile7() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile((x, i) => false); - - var e = ys.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void SkipWhile8() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile((x, i) => true); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void SkipWhile9() - { - var ex = new Exception("Bang"); - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable(); - var ys = xs.SkipWhile((x, i) => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void DefaultIfEmpty_Null() - { - AssertThrows(() => AsyncEnumerable.DefaultIfEmpty(null)); - AssertThrows(() => AsyncEnumerable.DefaultIfEmpty(null, 42)); - } - - [TestMethod] - public void DefaultIfEmpty1() - { - var xs = AsyncEnumerable.Empty().DefaultIfEmpty(); - - var e = xs.GetEnumerator(); - HasNext(e, 0); - NoNext(e); - } - - [TestMethod] - public void DefaultIfEmpty2() - { - var xs = AsyncEnumerable.Empty().DefaultIfEmpty(42); - - var e = xs.GetEnumerator(); - HasNext(e, 42); - NoNext(e); - } - - [TestMethod] - public void DefaultIfEmpty3() - { - var xs = AsyncEnumerable.Return(42).DefaultIfEmpty(); - - var e = xs.GetEnumerator(); - HasNext(e, 42); - NoNext(e); - } - - [TestMethod] - public void DefaultIfEmpty4() - { - var xs = AsyncEnumerable.Return(42).DefaultIfEmpty(24); - - var e = xs.GetEnumerator(); - HasNext(e, 42); - NoNext(e); - } - - [TestMethod] - public void DefaultIfEmpty5() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty(); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void DefaultIfEmpty6() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty(24); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void DefaultIfEmpty7() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex).DefaultIfEmpty(); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void DefaultIfEmpty8() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex).DefaultIfEmpty(24); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Distinct_Null() - { - AssertThrows(() => AsyncEnumerable.Distinct(null)); - AssertThrows(() => AsyncEnumerable.Distinct(null, new Eq())); - AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Distinct1() - { - var xs = new[] { 1, 2, 1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct(); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 5); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Distinct2() - { - var xs = new[] { 1, -2, -1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct(new Eq()); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, -2); - HasNext(e, 3); - HasNext(e, 5); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void Reverse_Null() - { - AssertThrows(() => AsyncEnumerable.Reverse(null)); - } - - [TestMethod] - public void Reverse1() - { - var xs = AsyncEnumerable.Empty(); - var ys = xs.Reverse(); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void Reverse2() - { - var xs = AsyncEnumerable.Return(42); - var ys = xs.Reverse(); - - var e = ys.GetEnumerator(); - HasNext(e, 42); - NoNext(e); - } - - [TestMethod] - public void Reverse3() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.Reverse(); - - var e = ys.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 2); - HasNext(e, 1); - NoNext(e); - } - - [TestMethod] - public void Reverse4() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.Reverse(); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void OrderBy_Null() - { - AssertThrows(() => AsyncEnumerable.OrderBy(null, x => x)); - AssertThrows(() => AsyncEnumerable.OrderBy(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.OrderBy(null, x => x, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.OrderBy(AsyncEnumerable.Return(42), null, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.OrderBy(AsyncEnumerable.Return(42), x => x, null)); - - AssertThrows(() => AsyncEnumerable.OrderByDescending(null, x => x)); - AssertThrows(() => AsyncEnumerable.OrderByDescending(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.OrderByDescending(null, x => x, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.OrderByDescending(AsyncEnumerable.Return(42), null, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.OrderByDescending(AsyncEnumerable.Return(42), x => x, null)); - - var xs = AsyncEnumerable.Return(42).OrderBy(x => x); - - AssertThrows(() => AsyncEnumerable.ThenBy(null, x => x)); - AssertThrows(() => AsyncEnumerable.ThenBy(xs, null)); - - AssertThrows(() => AsyncEnumerable.ThenBy(null, x => x, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.ThenBy(xs, null, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.ThenBy(xs, x => x, null)); - - AssertThrows(() => AsyncEnumerable.ThenByDescending(null, x => x)); - AssertThrows(() => AsyncEnumerable.ThenByDescending(xs, null)); - - AssertThrows(() => AsyncEnumerable.ThenByDescending(null, x => x, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.ThenByDescending(xs, null, Comparer.Default)); - AssertThrows(() => AsyncEnumerable.ThenByDescending(xs, x => x, null)); - } - - [TestMethod] - public void OrderBy1() - { - var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); - var ys = xs.OrderBy(x => x); - - var e = ys.GetEnumerator(); - for (int i = 0; i < 10; i++) - HasNext(e, i); - NoNext(e); - } - - [TestMethod] - public void OrderBy2() - { - var ex = new Exception("Bang!"); - var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); - var ys = xs.OrderBy(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ThenBy2() - { - var ex = new Exception("Bang!"); - var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); - var ys = xs.OrderBy(x => x).ThenBy(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void OrderByDescending1() - { - var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); - var ys = xs.OrderByDescending(x => x); - - var e = ys.GetEnumerator(); - for (int i = 9; i >= 0; i--) - HasNext(e, i); - NoNext(e); - } - - [TestMethod] - public void OrderByDescending2() - { - var ex = new Exception("Bang!"); - var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); - var ys = xs.OrderByDescending(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void ThenByDescending2() - { - var ex = new Exception("Bang!"); - var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable(); - var ys = xs.OrderBy(x => x).ThenByDescending(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void OrderByThenBy1() - { - var xs = new[] { - new { Name = "Bart", Age = 27 }, - new { Name = "John", Age = 62 }, - new { Name = "Eric", Age = 27 }, - new { Name = "Lisa", Age = 14 }, - new { Name = "Brad", Age = 27 }, - new { Name = "Lisa", Age = 23 }, - new { Name = "Eric", Age = 42 }, - }; - - var ys = xs.ToAsyncEnumerable(); - - var ress = xs.OrderBy(x => x.Name).ThenBy(x => x.Age); - var resa = ys.OrderBy(x => x.Name).ThenBy(x => x.Age); - - Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); - } - - [TestMethod] - public void OrderByThenBy2() - { - var xs = new[] { - new { Name = "Bart", Age = 27 }, - new { Name = "John", Age = 62 }, - new { Name = "Eric", Age = 27 }, - new { Name = "Lisa", Age = 14 }, - new { Name = "Brad", Age = 27 }, - new { Name = "Lisa", Age = 23 }, - new { Name = "Eric", Age = 42 }, - }; - - var ys = xs.ToAsyncEnumerable(); - - var ress = xs.OrderBy(x => x.Name).ThenByDescending(x => x.Age); - var resa = ys.OrderBy(x => x.Name).ThenByDescending(x => x.Age); - - Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); - } - - [TestMethod] - public void OrderByThenBy3() - { - var xs = new[] { - new { Name = "Bart", Age = 27 }, - new { Name = "John", Age = 62 }, - new { Name = "Eric", Age = 27 }, - new { Name = "Lisa", Age = 14 }, - new { Name = "Brad", Age = 27 }, - new { Name = "Lisa", Age = 23 }, - new { Name = "Eric", Age = 42 }, - }; - - var ys = xs.ToAsyncEnumerable(); - - var ress = xs.OrderByDescending(x => x.Name).ThenBy(x => x.Age); - var resa = ys.OrderByDescending(x => x.Name).ThenBy(x => x.Age); - - Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); - } - - [TestMethod] - public void OrderByThenBy4() - { - var xs = new[] { - new { Name = "Bart", Age = 27 }, - new { Name = "John", Age = 62 }, - new { Name = "Eric", Age = 27 }, - new { Name = "Lisa", Age = 14 }, - new { Name = "Brad", Age = 27 }, - new { Name = "Lisa", Age = 23 }, - new { Name = "Eric", Age = 42 }, - }; - - var ys = xs.ToAsyncEnumerable(); - - var ress = xs.OrderByDescending(x => x.Name).ThenByDescending(x => x.Age); - var resa = ys.OrderByDescending(x => x.Name).ThenByDescending(x => x.Age); - - Assert.IsTrue(ress.SequenceEqual(resa.ToEnumerable())); - } - - [TestMethod] - public void GroupBy_Null() - { - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(IEqualityComparer))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func), EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, default(IEqualityComparer))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, (x, ys) => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), (x, ys) => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func, int>))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, (x, ys) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), (x, ys) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func, int>), EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, (x, ys) => x, default(IEqualityComparer))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x, (x, ys) => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x, (x, ys) => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func), (x, ys) => x)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, default(Func, int>))); - - AssertThrows(() => AsyncEnumerable.GroupBy(null, x => x, x => x, (x, ys) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), default(Func), x => x, (x, ys) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, default(Func), (x, ys) => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, default(Func, int>), EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.GroupBy(AsyncEnumerable.Return(42), x => x, x => x, (x, ys) => x, default(IEqualityComparer))); - } - - [TestMethod] - public void GroupBy1() - { - var xs = new[] { - new { Name = "Bart", Age = 27 }, - new { Name = "John", Age = 62 }, - new { Name = "Eric", Age = 27 }, - new { Name = "Lisa", Age = 14 }, - new { Name = "Brad", Age = 27 }, - new { Name = "Lisa", Age = 23 }, - new { Name = "Eric", Age = 42 }, - }; - - var ys = xs.ToAsyncEnumerable(); - - var res = ys.GroupBy(x => x.Age / 10); - - var e = res.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - Assert.AreEqual(e.Current.Key, 2); - var g1 = e.Current.GetEnumerator(); - HasNext(g1, xs[0]); - HasNext(g1, xs[2]); - HasNext(g1, xs[4]); - HasNext(g1, xs[5]); - NoNext(g1); - - Assert.IsTrue(e.MoveNext().Result); - Assert.AreEqual(e.Current.Key, 6); - var g2 = e.Current.GetEnumerator(); - HasNext(g2, xs[1]); - NoNext(g2); - - Assert.IsTrue(e.MoveNext().Result); - Assert.AreEqual(e.Current.Key, 1); - var g3 = e.Current.GetEnumerator(); - HasNext(g3, xs[3]); - NoNext(g3); - - Assert.IsTrue(e.MoveNext().Result); - Assert.AreEqual(e.Current.Key, 4); - var g4 = e.Current.GetEnumerator(); - HasNext(g4, xs[6]); - NoNext(g4); - - NoNext(e); - } - - [TestMethod] - public void GroupBy2() - { - var xs = new[] { - new { Name = "Bart", Age = 27 }, - new { Name = "John", Age = 62 }, - new { Name = "Eric", Age = 27 }, - new { Name = "Lisa", Age = 14 }, - new { Name = "Brad", Age = 27 }, - new { Name = "Lisa", Age = 23 }, - new { Name = "Eric", Age = 42 }, - }; - - var ys = xs.ToAsyncEnumerable(); - - var res = ys.GroupBy(x => x.Age / 10); - - var e = res.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 2); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 6); - - Assert.IsTrue(e.MoveNext().Result); - var g3 = e.Current; - Assert.AreEqual(g3.Key, 1); - - Assert.IsTrue(e.MoveNext().Result); - var g4 = e.Current; - Assert.AreEqual(g4.Key, 4); - - NoNext(e); - - var g1e = g1.GetEnumerator(); - HasNext(g1e, xs[0]); - HasNext(g1e, xs[2]); - HasNext(g1e, xs[4]); - HasNext(g1e, xs[5]); - NoNext(g1e); - - var g2e = g2.GetEnumerator(); - HasNext(g2e, xs[1]); - NoNext(g2e); - - var g3e = g3.GetEnumerator(); - HasNext(g3e, xs[3]); - NoNext(g3e); - - var g4e = g4.GetEnumerator(); - HasNext(g4e, xs[6]); - NoNext(g4e); - } - - [TestMethod] - public void GroupBy3() - { - var xs = AsyncEnumerable.Empty(); - var ys = xs.GroupBy(x => x); - - var e = ys.GetEnumerator(); - NoNext(e); - } - - [TestMethod] - public void GroupBy4() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex); - var ys = xs.GroupBy(x => x); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupBy5() - { - var xs = GetXs().ToAsyncEnumerable(); - var ys = xs.GroupBy(x => x); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 42); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 42); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 43); - var g2e = g2.GetEnumerator(); - HasNext(g2e, 43); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - AssertThrows(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - AssertThrows(() => g2e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - } - - [TestMethod] - public void GroupBy6() - { - var xs = GetXs().ToAsyncEnumerable(); - var ys = xs.GroupBy(x => x); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 42); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 42); - AssertThrows(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!"); - } - - static IEnumerable GetXs() - { - yield return 42; - yield return 43; - throw new Exception("Bang!"); - } - - [TestMethod] - public void GroupBy7() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Return(42); - var ys = xs.GroupBy(x => { throw ex; }); - - var e = ys.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupBy8() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); - var ys = xs.GroupBy(x => { if (x == 3) throw ex; return x; }); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 1); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 1); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 2); - var g2e = g2.GetEnumerator(); - HasNext(g2e, 2); - - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - AssertThrows(() => g1e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - AssertThrows(() => g2e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void GroupBy9() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x)); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 0); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 'a'); - HasNext(g1e, 'd'); - HasNext(g1e, 'g'); - HasNext(g1e, 'j'); - NoNext(g1e); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 1); - var g2e = g2.GetEnumerator(); - HasNext(g2e, 'b'); - HasNext(g2e, 'e'); - HasNext(g2e, 'h'); - NoNext(g2e); - - Assert.IsTrue(e.MoveNext().Result); - var g3 = e.Current; - Assert.AreEqual(g3.Key, 2); - var g3e = g3.GetEnumerator(); - HasNext(g3e, 'c'); - HasNext(g3e, 'f'); - HasNext(g3e, 'i'); - NoNext(g3e); - - NoNext(e); - } - - [TestMethod] - public void GroupBy10() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result); - - var e = ys.GetEnumerator(); - HasNext(e, "0 - adgj"); - HasNext(e, "1 - beh"); - HasNext(e, "2 - cfi"); - NoNext(e); - } - - [TestMethod] - public void GroupBy11() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x % 3, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result); - - var e = ys.GetEnumerator(); - HasNext(e, "0 - 0369"); - HasNext(e, "1 - 147"); - HasNext(e, "2 - 258"); - NoNext(e); - } - - [TestMethod] - public void GroupBy12() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, new EqMod(3)); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 0); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 0); - HasNext(g1e, 3); - HasNext(g1e, 6); - HasNext(g1e, 9); - NoNext(g1e); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 1); - var g2e = g2.GetEnumerator(); - HasNext(g2e, 1); - HasNext(g2e, 4); - HasNext(g2e, 7); - NoNext(g2e); - - Assert.IsTrue(e.MoveNext().Result); - var g3 = e.Current; - Assert.AreEqual(g3.Key, 2); - var g3e = g3.GetEnumerator(); - HasNext(g3e, 2); - HasNext(g3e, 5); - HasNext(g3e, 8); - NoNext(g3e); - - NoNext(e); - } - - [TestMethod] - public void GroupBy13() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 0); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 'a'); - HasNext(g1e, 'd'); - HasNext(g1e, 'g'); - HasNext(g1e, 'j'); - NoNext(g1e); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 1); - var g2e = g2.GetEnumerator(); - HasNext(g2e, 'b'); - HasNext(g2e, 'e'); - HasNext(g2e, 'h'); - NoNext(g2e); - - Assert.IsTrue(e.MoveNext().Result); - var g3 = e.Current; - Assert.AreEqual(g3.Key, 2); - var g3e = g3.GetEnumerator(); - HasNext(g3e, 'c'); - HasNext(g3e, 'f'); - HasNext(g3e, 'i'); - NoNext(g3e); - - NoNext(e); - } - - [TestMethod] - public void GroupBy14() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3)); - - var e = ys.GetEnumerator(); - HasNext(e, "0 - adgj"); - HasNext(e, "1 - beh"); - HasNext(e, "2 - cfi"); - NoNext(e); - } - - [TestMethod] - public void GroupBy15() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3)); - - var e = ys.GetEnumerator(); - HasNext(e, "0 - 0369"); - HasNext(e, "1 - 147"); - HasNext(e, "2 - 258"); - NoNext(e); - } - - [TestMethod] - public void GroupBy16() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 0); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 'a'); - HasNext(g1e, 'd'); - HasNext(g1e, 'g'); - HasNext(g1e, 'j'); - NoNext(g1e); - g1e.Dispose(); - - Assert.IsTrue(e.MoveNext().Result); - var g2 = e.Current; - Assert.AreEqual(g2.Key, 1); - var g2e = g2.GetEnumerator(); - HasNext(g2e, 'b'); - HasNext(g2e, 'e'); - HasNext(g2e, 'h'); - NoNext(g2e); - g2e.Dispose(); - - Assert.IsTrue(e.MoveNext().Result); - var g3 = e.Current; - Assert.AreEqual(g3.Key, 2); - var g3e = g3.GetEnumerator(); - HasNext(g3e, 'c'); - HasNext(g3e, 'f'); - HasNext(g3e, 'i'); - NoNext(g3e); - g3e.Dispose(); - - NoNext(e); - - e.Dispose(); - } - - [TestMethod] - public void GroupBy17() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); - - var e = ys.GetEnumerator(); - e.Dispose(); - - Assert.IsFalse(e.MoveNext().Result); - } - - [TestMethod] - public void GroupBy18() - { - var xs = AsyncEnumerable.Range(0, 10); - var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3)); - - var e = ys.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - var g1 = e.Current; - Assert.AreEqual(g1.Key, 0); - var g1e = g1.GetEnumerator(); - HasNext(g1e, 'a'); - - e.Dispose(); - - HasNext(g1e, 'd'); - HasNext(g1e, 'g'); - HasNext(g1e, 'j'); - NoNext(g1e); - g1e.Dispose(); - - Assert.IsFalse(e.MoveNext().Result); - } - - class EqMod : IEqualityComparer - { - private readonly int _d; - - public EqMod(int d) - { - _d = d; - } - - public bool Equals(int x, int y) - { - return EqualityComparer.Default.Equals(x % _d, y % _d); - } - - public int GetHashCode(int obj) - { - return EqualityComparer.Default.GetHashCode(obj % _d); - } - } - - [TestMethod] - public void AsAsyncEnumerable_Null() - { - AssertThrows(() => AsyncEnumerable.AsAsyncEnumerable(null)); - } - - [TestMethod] - public void AsAsyncEnumerable1() - { - var xs = AsyncEnumerable.Return(42); - var ys = xs.AsAsyncEnumerable(); - - Assert.AreNotSame(xs, ys); - - var e = xs.GetEnumerator(); - HasNext(e, 42); - NoNext(e); - } - - [TestMethod] - public void RepeatSeq_Null() - { - AssertThrows(() => AsyncEnumerable.Repeat(default(IAsyncEnumerable))); - AssertThrows(() => AsyncEnumerable.Repeat(default(IAsyncEnumerable), 3)); - AssertThrows(() => AsyncEnumerable.Repeat(AsyncEnumerable.Return(42), -1)); - } - - [TestMethod] - public void RepeatSeq1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat(); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - } - - [TestMethod] - public void RepeatSeq2() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat(3); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - NoNext(e); - } - - [TestMethod] - public void RepeatSeq3() - { - var i = 0; - var xs = RepeatXs(() => i++).ToAsyncEnumerable().Repeat(3); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - - Assert.AreEqual(3, i); - } - - static IEnumerable RepeatXs(Action started) - { - started(); - - yield return 1; - yield return 2; - } - - [TestMethod] - public void RepeatSeq4() - { - var xs = new FailRepeat().ToAsyncEnumerable().Repeat(); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException); - } - - [TestMethod] - public void RepeatSeq5() - { - var xs = new FailRepeat().ToAsyncEnumerable().Repeat(3); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException); - } - - class FailRepeat : IEnumerable - { - public IEnumerator GetEnumerator() - { - throw new NotImplementedException(); - } - - System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() - { - throw new NotImplementedException(); - } - } - - [TestMethod] - public void IgnoreElements_Null() - { - AssertThrows(() => AsyncEnumerable.IgnoreElements(default(IAsyncEnumerable))); - } - - [TestMethod] - public void IgnoreElements1() - { - var xs = AsyncEnumerable.Empty().IgnoreElements(); - - var e = xs.GetEnumerator(); - NoNext(e); - - AssertThrows(() => { var ignored = e.Current; }); - } - - [TestMethod] - public void IgnoreElements2() - { - var xs = AsyncEnumerable.Return(42).IgnoreElements(); - - var e = xs.GetEnumerator(); - NoNext(e); - - AssertThrows(() => { var ignored = e.Current; }); - } - - [TestMethod] - public void IgnoreElements3() - { - var xs = AsyncEnumerable.Range(0, 10).IgnoreElements(); - - var e = xs.GetEnumerator(); - NoNext(e); - - AssertThrows(() => { var ignored = e.Current; }); - } - - [TestMethod] - public void IgnoreElements4() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex).IgnoreElements(); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void StartWith_Null() - { - AssertThrows(() => AsyncEnumerable.StartWith(default(IAsyncEnumerable), new[] { 1 })); - AssertThrows(() => AsyncEnumerable.StartWith(AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void StartWith1() - { - var xs = AsyncEnumerable.Empty().StartWith(1, 2); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void StartWith2() - { - var xs = AsyncEnumerable.Return(0).StartWith(1, 2); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 0); - NoNext(e); - } - - [TestMethod] - public void StartWith3() - { - var ex = new Exception("Bang!"); - var xs = AsyncEnumerable.Throw(ex).StartWith(1, 2); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Buffer_Null() - { - AssertThrows(() => AsyncEnumerable.Buffer(default(IAsyncEnumerable), 1)); - AssertThrows(() => AsyncEnumerable.Buffer(default(IAsyncEnumerable), 1, 1)); - - AssertThrows(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), -1)); - AssertThrows(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), -1, 1)); - AssertThrows(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), 1, -1)); - } - - [TestMethod] - public void Buffer1() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(2); - - var e = xs.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 1, 2 })); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 3, 4 })); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 5 })); - - Assert.IsFalse(e.MoveNext().Result); - } - - [TestMethod] - public void Buffer2() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(3, 2); - - var e = xs.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 1, 2, 3 })); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 3, 4, 5 })); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 5 })); - - Assert.IsFalse(e.MoveNext().Result); - } - - [TestMethod] - public void Buffer3() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(2, 3); - - var e = xs.GetEnumerator(); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 1, 2 })); - - Assert.IsTrue(e.MoveNext().Result); - Assert.IsTrue(e.Current.SequenceEqual(new[] { 4, 5 })); - - Assert.IsFalse(e.MoveNext().Result); - } - - [TestMethod] - public void DistinctUntilChanged_Null() - { - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable))); - - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable), EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(IEqualityComparer))); - - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(Func))); - - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable), x => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(Func), EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), x => x, default(IEqualityComparer))); - } - - [TestMethod] - public void DistinctUntilChanged1() - { - var xs = new[] { 1, 2, 2, 3, 4, 4, 4, 4, 5, 6, 6, 7, 3, 2, 2, 1, 1 }.ToAsyncEnumerable().DistinctUntilChanged(); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - HasNext(e, 5); - HasNext(e, 6); - HasNext(e, 7); - HasNext(e, 3); - HasNext(e, 2); - HasNext(e, 1); - NoNext(e); - } - - [TestMethod] - public void DistinctUntilChanged2() - { - var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => (x + 1) / 2); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 3); - HasNext(e, 5); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void DistinctUntilChanged3() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => { if (x == 4) throw ex; return x; }); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Expand_Null() - { - AssertThrows(() => AsyncEnumerable.Expand(default(IAsyncEnumerable), x => null)); - AssertThrows(() => AsyncEnumerable.Expand(AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Expand1() - { - var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => AsyncEnumerable.Return(x - 1).Repeat(x - 1)); - - var e = xs.GetEnumerator(); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 2); - HasNext(e, 1); - HasNext(e, 1); - NoNext(e); - } - - [TestMethod] - public void Expand2() - { - var ex = new Exception("Bang!"); - var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => { throw ex; }); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Expand3() - { - var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => null); - - var e = xs.GetEnumerator(); - HasNext(e, 2); - HasNext(e, 3); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NullReferenceException); - } - - [TestMethod] - public void Scan_Null() - { - AssertThrows(() => AsyncEnumerable.Scan(default(IAsyncEnumerable), 3, (x, y) => x + y)); - AssertThrows(() => AsyncEnumerable.Scan(AsyncEnumerable.Return(42), 3, null)); - - AssertThrows(() => AsyncEnumerable.Scan(default(IAsyncEnumerable), (x, y) => x + y)); - AssertThrows(() => AsyncEnumerable.Scan(AsyncEnumerable.Return(42), null)); - } - - [TestMethod] - public void Scan1() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => x + y); - - var e = xs.GetEnumerator(); - HasNext(e, 9); - HasNext(e, 11); - HasNext(e, 14); - NoNext(e); - } - - [TestMethod] - public void Scan2() - { - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => x + y); - - var e = xs.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 6); - NoNext(e); - } - - [TestMethod] - public void Scan3() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => { throw ex; }); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void Scan4() - { - var ex = new Exception("Bang!"); - var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => { throw ex; }); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex); - } - - [TestMethod] - public void DistinctKey_Null() - { - AssertThrows(() => AsyncEnumerable.Distinct(default(IAsyncEnumerable), x => x)); - AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null)); - - AssertThrows(() => AsyncEnumerable.Distinct(default(IAsyncEnumerable), x => x, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null, EqualityComparer.Default)); - AssertThrows(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), x => x, null)); - } - - [TestMethod] - public void DistinctKey1() - { - var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Distinct(x => x / 2); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void TakeLast_Null() - { - AssertThrows(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable), 5)); - AssertThrows(() => AsyncEnumerable.TakeLast(AsyncEnumerable.Return(42), -1)); - } - - [TestMethod] - public void TakeLast1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2); - - var e = xs.GetEnumerator(); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void TakeLast2() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(5); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - HasNext(e, 4); - NoNext(e); - } - - [TestMethod] - public void SkipLast_Null() - { - AssertThrows(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable), 5)); - AssertThrows(() => AsyncEnumerable.SkipLast(AsyncEnumerable.Return(42), -1)); - } - - [TestMethod] - public void SkipLast1() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2); - - var e = xs.GetEnumerator(); - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - } - - [TestMethod] - public void SkipLast2() - { - var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(5); - - var e = xs.GetEnumerator(); - NoNext(e); - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/AsyncTests.cs b/Ix/Tests/AsyncTests.cs deleted file mode 100644 index 9279bb7..0000000 --- a/Ix/Tests/AsyncTests.cs +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if DESKTOPCLR40 - -using System; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - [TestClass] - public partial class AsyncTests - { - public void AssertThrows(Action a) - where E : Exception - { - try - { - a(); - Assert.Fail(); - } - catch (E) - { - } - } - - public void AssertThrows(Action a, Func assert) - where E : Exception - { - try - { - a(); - Assert.Fail(); - } - catch (E e) - { - Assert.IsTrue(assert(e)); - } - } - - public void NoNext(IAsyncEnumerator e) - { - Assert.IsFalse(e.MoveNext().Result); - } - - public void HasNext(IAsyncEnumerator e, T value) - { - Assert.IsTrue(e.MoveNext().Result); - Assert.AreEqual(value, e.Current); - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/Properties/AppManifest.xml b/Ix/Tests/Properties/AppManifest.xml deleted file mode 100644 index 71b66f8..0000000 --- a/Ix/Tests/Properties/AppManifest.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - diff --git a/Ix/Tests/Properties/AssemblyInfo.cs b/Ix/Tests/Properties/AssemblyInfo.cs deleted file mode 100644 index 6536c5c..0000000 --- a/Ix/Tests/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,35 +0,0 @@ -using System.Reflection; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -// General Information about an assembly is controlled through the following -// set of attributes. Change these attribute values to modify the information -// associated with an assembly. -[assembly: AssemblyTitle("Tests")] -[assembly: AssemblyDescription("")] -[assembly: AssemblyConfiguration("")] -[assembly: AssemblyCompany("Microsoft")] -[assembly: AssemblyProduct("Tests")] -[assembly: AssemblyCopyright("Copyright © Microsoft 2011")] -[assembly: AssemblyTrademark("")] -[assembly: AssemblyCulture("")] - -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from -// COM, set the ComVisible attribute to true on that type. -[assembly: ComVisible(false)] - -// The following GUID is for the ID of the typelib if this project is exposed to COM -[assembly: Guid("aec256c2-1e0e-48d7-a312-7184dc67b1f0")] - -// Version information for an assembly consists of the following four values: -// -// Major Version -// Minor Version -// Build Number -// Revision -// -// You can specify all the values or you can default the Build and Revision Numbers -// by using the '*' as shown below: -//[assembly: AssemblyVersion("1.0.0.0")] -//[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Ix/Tests/Tests.Aggregates.cs b/Ix/Tests/Tests.Aggregates.cs deleted file mode 100644 index 8fd8cee..0000000 --- a/Ix/Tests/Tests.Aggregates.cs +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void IsEmtpy_Arguments() - { - AssertThrows(() => EnumerableEx.IsEmpty(null)); - } - - [TestMethod] - public void IsEmpty_Empty() - { - Assert.IsTrue(Enumerable.Empty().IsEmpty()); - } - - [TestMethod] - public void IsEmpty_NonEmpty() - { - Assert.IsFalse(new[] { 1 }.IsEmpty()); - } - - [TestMethod] - public void Min_Arguments() - { - AssertThrows(() => EnumerableEx.Min(null, Comparer.Default)); - AssertThrows(() => EnumerableEx.Min(new[] { 1 }, null)); - } - - [TestMethod] - public void Min() - { - Assert.AreEqual(3, new[] { 5, 3, 7 }.Min(new Mod3Comparer())); - } - - class Mod3Comparer : IComparer - { - public int Compare(int x, int y) - { - return Comparer.Default.Compare(x % 3, y % 3); - } - } - - [TestMethod] - public void MinBy_Arguments() - { - AssertThrows(() => EnumerableEx.MinBy(null, (int x) => x)); - AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, default(Func))); - AssertThrows(() => EnumerableEx.MinBy(null, (int x) => x, Comparer.Default)); - AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, default(Func), Comparer.Default)); - AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, (int x) => x, null)); - } - - [TestMethod] - public void MinBy() - { - var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MinBy(x => x % 3); - Assert.IsTrue(res.SequenceEqual(new[] { 0, 3, 6 })); - } - - [TestMethod] - public void MinBy_Empty() - { - AssertThrows(() => Enumerable.Empty().MinBy(x => x)); - } - - [TestMethod] - public void Max_Arguments() - { - AssertThrows(() => EnumerableEx.Max(null, Comparer.Default)); - AssertThrows(() => EnumerableEx.Max(new[] { 1 }, null)); - } - - [TestMethod] - public void Max() - { - Assert.AreEqual(5, new[] { 2, 5, 3, 7 }.Max(new Mod7Comparer())); - } - - class Mod7Comparer : IComparer - { - public int Compare(int x, int y) - { - return Comparer.Default.Compare(x % 7, y % 7); - } - } - - [TestMethod] - public void MaxBy_Arguments() - { - AssertThrows(() => EnumerableEx.MaxBy(null, (int x) => x)); - AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, default(Func))); - AssertThrows(() => EnumerableEx.MaxBy(null, (int x) => x, Comparer.Default)); - AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, default(Func), Comparer.Default)); - AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, (int x) => x, null)); - } - - [TestMethod] - public void MaxBy() - { - var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MaxBy(x => x % 3); - Assert.IsTrue(res.SequenceEqual(new[] { 2, 5, 2 })); - } - - [TestMethod] - public void MaxBy_Empty() - { - AssertThrows(() => Enumerable.Empty().MaxBy(x => x)); - } - } -} diff --git a/Ix/Tests/Tests.Buffering.cs b/Ix/Tests/Tests.Buffering.cs deleted file mode 100644 index 0f6e81c..0000000 --- a/Ix/Tests/Tests.Buffering.cs +++ /dev/null @@ -1,625 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Collections; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void Share_Arguments() - { - AssertThrows(() => EnumerableEx.Share(null)); - } - - [TestMethod] - public void Share1() - { - var rng = Enumerable.Range(0, 5).Share(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - HasNext(e1, 3); - HasNext(e1, 4); - NoNext(e1); - } - - [TestMethod] - public void Share2() - { - var rng = Enumerable.Range(0, 5).Share(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e2, 1); - HasNext(e1, 2); - HasNext(e2, 3); - HasNext(e1, 4); - NoNext(e2); - NoNext(e1); - } - - [TestMethod] - public void Share3() - { - var rng = Enumerable.Range(0, 5).Share(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - var e2 = rng.GetEnumerator(); - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e2); - NoNext(e1); - } - - [TestMethod] - public void Share4() - { - var rng = Enumerable.Range(0, 5).Share(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - e1.Dispose(); - Assert.IsFalse(e1.MoveNext()); - } - - [TestMethod] - public void Share5() - { - var rng = Enumerable.Range(0, 5).Share(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - rng.Dispose(); - AssertThrows(() => e1.MoveNext()); - AssertThrows(() => rng.GetEnumerator()); - AssertThrows(() => ((IEnumerable)rng).GetEnumerator()); - } - - [TestMethod] - public void Share6() - { - var rng = Enumerable.Range(0, 5).Share(); - - var e1 = ((IEnumerable)rng).GetEnumerator(); - Assert.IsTrue(e1.MoveNext()); - Assert.AreEqual(0, (int)e1.Current); - } - - [TestMethod] - public void Publish_Arguments() - { - AssertThrows(() => EnumerableEx.Publish(null)); - } - - [TestMethod] - public void Publish0() - { - var n = 0; - var rng = Tick(i => n += i).Publish(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - - HasNext(e1, 0); - Assert.AreEqual(0, n); - - HasNext(e1, 1); - Assert.AreEqual(1, n); - - HasNext(e1, 2); - Assert.AreEqual(3, n); - HasNext(e2, 0); - Assert.AreEqual(3, n); - - HasNext(e1, 3); - Assert.AreEqual(6, n); - HasNext(e2, 1); - Assert.AreEqual(6, n); - - HasNext(e2, 2); - Assert.AreEqual(6, n); - HasNext(e2, 3); - Assert.AreEqual(6, n); - - HasNext(e2, 4); - Assert.AreEqual(10, n); - HasNext(e1, 4); - Assert.AreEqual(10, n); - } - - static IEnumerable Tick(Action t) - { - var i = 0; - while (true) - { - t(i); - yield return i++; - } - } - - [TestMethod] - public void Publish1() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - HasNext(e1, 3); - HasNext(e1, 4); - NoNext(e1); - } - - [TestMethod] - public void Publish2() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e2, 0); - HasNext(e1, 1); - HasNext(e2, 1); - HasNext(e1, 2); - HasNext(e2, 2); - HasNext(e1, 3); - HasNext(e2, 3); - HasNext(e1, 4); - HasNext(e2, 4); - NoNext(e1); - NoNext(e2); - } - - [TestMethod] - public void Publish3() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - HasNext(e1, 3); - HasNext(e1, 4); - HasNext(e2, 0); - HasNext(e2, 1); - HasNext(e2, 2); - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e1); - NoNext(e2); - } - - [TestMethod] - public void Publish4() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - var e2 = rng.GetEnumerator(); - HasNext(e1, 3); - HasNext(e1, 4); - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e1); - NoNext(e2); - } - - [TestMethod] - public void Publish5() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - e1.Dispose(); - - var e2 = rng.GetEnumerator(); - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e2); - } - - [TestMethod] - public void Publish6() - { - var ex = new MyException(); - var rng = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw(ex)).Publish(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - AssertThrows(() => e1.MoveNext()); - - HasNext(e2, 0); - HasNext(e2, 1); - AssertThrows(() => e2.MoveNext()); - } - - class MyException : Exception - { - } - - [TestMethod] - public void Publish7() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - var e2 = rng.GetEnumerator(); - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e2); - - HasNext(e1, 3); - HasNext(e1, 4); - NoNext(e2); - - var e3 = rng.GetEnumerator(); - NoNext(e3); - } - - [TestMethod] - public void Publish8() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - rng.Dispose(); - AssertThrows(() => e1.MoveNext()); - AssertThrows(() => rng.GetEnumerator()); - AssertThrows(() => ((IEnumerable)rng).GetEnumerator()); - } - - [TestMethod] - public void Publish9() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = ((IEnumerable)rng).GetEnumerator(); - Assert.IsTrue(e1.MoveNext()); - Assert.AreEqual(0, (int)e1.Current); - } - - [TestMethod] - public void Publish10() - { - var rnd = Rand().Take(1000).Publish(); - Assert.IsTrue(rnd.Zip(rnd, (l, r) => l == r).All(x => x)); - } - - [TestMethod] - public void Memoize_Arguments() - { - AssertThrows(() => EnumerableEx.Memoize(null)); - } - - [TestMethod] - public void MemoizeLimited_Arguments() - { - AssertThrows(() => EnumerableEx.Memoize(null, 2)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 0)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, -1)); - } - - [TestMethod] - public void Memoize0() - { - var n = 0; - var rng = Tick(i => n += i).Memoize(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - - HasNext(e1, 0); - Assert.AreEqual(0, n); - - HasNext(e1, 1); - Assert.AreEqual(1, n); - - HasNext(e1, 2); - Assert.AreEqual(3, n); - HasNext(e2, 0); - Assert.AreEqual(3, n); - - HasNext(e1, 3); - Assert.AreEqual(6, n); - HasNext(e2, 1); - Assert.AreEqual(6, n); - - HasNext(e2, 2); - Assert.AreEqual(6, n); - HasNext(e2, 3); - Assert.AreEqual(6, n); - - HasNext(e2, 4); - Assert.AreEqual(10, n); - HasNext(e1, 4); - Assert.AreEqual(10, n); - } - - [TestMethod] - public void Publish11() - { - var rng = Enumerable.Range(0, 5).Publish(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - e1.Dispose(); - - HasNext(e2, 0); - HasNext(e2, 1); - e2.Dispose(); - - var e3 = rng.GetEnumerator(); - HasNext(e3, 3); - HasNext(e3, 4); - NoNext(e3); - } - - [TestMethod] - public void Memoize1() - { - var rng = Enumerable.Range(0, 5).Memoize(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - HasNext(e1, 3); - HasNext(e1, 4); - NoNext(e1); - } - - [TestMethod] - public void Memoize2() - { - var rng = Enumerable.Range(0, 5).Memoize(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - HasNext(e1, 3); - HasNext(e1, 4); - NoNext(e1); - - var e2 = rng.GetEnumerator(); - HasNext(e2, 0); - HasNext(e2, 1); - HasNext(e2, 2); - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e2); - } - - [TestMethod] - public void Memoize3() - { - var rng = Enumerable.Range(0, 5).Memoize(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - var e2 = rng.GetEnumerator(); - HasNext(e1, 3); - HasNext(e2, 0); - HasNext(e2, 1); - HasNext(e1, 4); - HasNext(e2, 2); - NoNext(e1); - - HasNext(e2, 3); - HasNext(e2, 4); - NoNext(e2); - } - - [TestMethod] - public void Memoize4() - { - var rng = Enumerable.Range(0, 5).Memoize(2); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - var e2 = rng.GetEnumerator(); - HasNext(e2, 0); - HasNext(e2, 1); - HasNext(e2, 2); - - var e3 = rng.GetEnumerator(); - AssertThrows(() => e3.MoveNext()); - } - - [TestMethod] - public void Memoize6() - { - var ex = new MyException(); - var rng = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw(ex)).Memoize(); - - var e1 = rng.GetEnumerator(); - var e2 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - AssertThrows(() => e1.MoveNext()); - - HasNext(e2, 0); - HasNext(e2, 1); - AssertThrows(() => e2.MoveNext()); - } - - [TestMethod] - public void Memoize7() - { - var rng = Enumerable.Range(0, 5).Memoize(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - e1.Dispose(); - - var e2 = rng.GetEnumerator(); - HasNext(e2, 0); - HasNext(e2, 1); - e2.Dispose(); - - var e3 = rng.GetEnumerator(); - HasNext(e3, 0); - HasNext(e3, 1); - HasNext(e3, 2); - HasNext(e3, 3); - HasNext(e3, 4); - NoNext(e3); - } - - [TestMethod] - public void Memoize8() - { - var rng = Enumerable.Range(0, 5).Memoize(); - - var e1 = rng.GetEnumerator(); - HasNext(e1, 0); - HasNext(e1, 1); - HasNext(e1, 2); - - rng.Dispose(); - AssertThrows(() => e1.MoveNext()); - AssertThrows(() => rng.GetEnumerator()); - AssertThrows(() => ((IEnumerable)rng).GetEnumerator()); - } - - [TestMethod] - public void Memoize9() - { - var rng = Enumerable.Range(0, 5).Memoize(); - - var e1 = ((IEnumerable)rng).GetEnumerator(); - Assert.IsTrue(e1.MoveNext()); - Assert.AreEqual(0, (int)e1.Current); - } - - [TestMethod] - public void Memoize10() - { - var rnd = Rand().Take(1000).Memoize(); - Assert.IsTrue(rnd.Zip(rnd, (l, r) => l == r).All(x => x)); - } - - static Random s_rand = new Random(); - - static IEnumerable Rand() - { - while (true) - yield return s_rand.Next(); - } - - [TestMethod] - public void ShareLambda_Arguments() - { - AssertThrows(() => EnumerableEx.Share(null, xs => xs)); - AssertThrows(() => EnumerableEx.Share(new[] { 1 }, null)); - } - - [TestMethod] - public void ShareLambda() - { - var n = 0; - var res = Enumerable.Range(0, 10).Do(_ => n++).Share(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); - Assert.IsTrue(res.SequenceEqual(new[] { 0 + 1, 2 + 3, 4 + 5, 6 + 7 })); - Assert.AreEqual(8, n); - } - - [TestMethod] - public void PublishLambda_Arguments() - { - AssertThrows(() => EnumerableEx.Publish(null, xs => xs)); - AssertThrows(() => EnumerableEx.Publish(new[] { 1 }, null)); - } - - [TestMethod] - public void PublishLambda() - { - var n = 0; - var res = Enumerable.Range(0, 10).Do(_ => n++).Publish(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2))); - Assert.AreEqual(4, n); - } - - [TestMethod] - public void MemoizeLambda_Arguments() - { - AssertThrows(() => EnumerableEx.Memoize(null, xs => xs)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, null)); - } - - [TestMethod] - public void MemoizeLambda() - { - var n = 0; - var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2))); - Assert.AreEqual(4, n); - } - - [TestMethod] - public void MemoizeLimitedLambda_Arguments() - { - AssertThrows(() => EnumerableEx.Memoize(null, 2, xs => xs)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 2, null)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 0, xs => xs)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, -1, xs => xs)); - } - - [TestMethod] - public void MemoizeLimitedLambda() - { - var n = 0; - var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(2, xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2))); - Assert.AreEqual(4, n); - } - } -} diff --git a/Ix/Tests/Tests.Creation.cs b/Ix/Tests/Tests.Creation.cs deleted file mode 100644 index 81fee03..0000000 --- a/Ix/Tests/Tests.Creation.cs +++ /dev/null @@ -1,224 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Collections; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void Create_Arguments() - { - AssertThrows(() => EnumerableEx.Create(default(Func>))); - } - - [TestMethod] - public void Create1() - { - var hot = false; - var res = EnumerableEx.Create(() => - { - hot = true; - return MyEnumerator(); - }); - - Assert.IsFalse(hot); - - var e = res.GetEnumerator(); - Assert.IsTrue(hot); - - HasNext(e, 1); - HasNext(e, 2); - NoNext(e); - - hot = false; - var f = ((IEnumerable)res).GetEnumerator(); - Assert.IsTrue(hot); - } - - private static IEnumerator MyEnumerator() - { - yield return 1; - yield return 2; - } - - [TestMethod] - public void Return() - { - Assert.AreEqual(42, EnumerableEx.Return(42).Single()); - } - - [TestMethod] - public void Throw_Arguments() - { - AssertThrows(() => EnumerableEx.Throw(null)); - } - - [TestMethod] - public void Throw() - { - var ex = new MyException(); - var xs = EnumerableEx.Throw(ex); - - var e = xs.GetEnumerator(); - AssertThrows(() => e.MoveNext()); - } - - [TestMethod] - public void Defer_Arguments() - { - AssertThrows(() => EnumerableEx.Defer(null)); - } - - [TestMethod] - public void Defer1() - { - var i = 0; - var n = 5; - var xs = EnumerableEx.Defer(() => - { - i++; - return Enumerable.Range(0, n); - }); - - Assert.AreEqual(0, i); - - Assert.IsTrue(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n))); - Assert.AreEqual(1, i); - - n = 3; - Assert.IsTrue(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n))); - Assert.AreEqual(2, i); - } - - [TestMethod] - public void Defer2() - { - var xs = EnumerableEx.Defer(() => - { - throw new MyException(); - }); - - AssertThrows(() => xs.GetEnumerator().MoveNext()); - } - - [TestMethod] - public void Generate_Arguments() - { - AssertThrows(() => EnumerableEx.Generate(0, null, _ => _, _ => _)); - AssertThrows(() => EnumerableEx.Generate(0, _ => true, null, _ => _)); - AssertThrows(() => EnumerableEx.Generate(0, _ => true, _ => _, null)); - } - - [TestMethod] - public void Generate() - { - var res = EnumerableEx.Generate(0, x => x < 5, x => x + 1, x => x * x).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0, 1, 4, 9, 16 })); - } - - [TestMethod] - public void Using_Arguments() - { - AssertThrows(() => EnumerableEx.Using(null, d => new[] { 1 })); - AssertThrows(() => EnumerableEx.Using(() => new MyDisposable(), null)); - } - - [TestMethod] - public void Using1() - { - var d = default(MyDisposable); - - var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => new[] { 1 }); - Assert.IsNull(d); - - var d1 = default(MyDisposable); - xs.ForEach(_ => { d1 = d; Assert.IsNotNull(d1); Assert.IsFalse(d1.Done); }); - Assert.IsTrue(d1.Done); - - var d2 = default(MyDisposable); - xs.ForEach(_ => { d2 = d; Assert.IsNotNull(d2); Assert.IsFalse(d2.Done); }); - Assert.IsTrue(d2.Done); - - Assert.AreNotSame(d1, d2); - } - - [TestMethod] - public void Using2() - { - var d = default(MyDisposable); - - var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => EnumerableEx.Throw(new MyException())); - Assert.IsNull(d); - - AssertThrows(() => xs.ForEach(_ => { })); - Assert.IsTrue(d.Done); - } - - [TestMethod] - public void Using3() - { - var d = default(MyDisposable); - - var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => { throw new MyException(); }); - Assert.IsNull(d); - - AssertThrows(() => xs.ForEach(_ => { })); - Assert.IsTrue(d.Done); - } - - class MyDisposable : IDisposable - { - public bool Done; - - public void Dispose() - { - Done = true; - } - } - - [TestMethod] - public void RepeatElementInfinite() - { - var xs = EnumerableEx.Repeat(42).Take(1000); - Assert.IsTrue(xs.All(x => x == 42)); - Assert.IsTrue(xs.Count() == 1000); - } - - [TestMethod] - public void RepeatSequence_Arguments() - { - AssertThrows(() => EnumerableEx.Repeat(null)); - AssertThrows(() => EnumerableEx.Repeat(null, 5)); - AssertThrows(() => EnumerableEx.Repeat(new[] { 1 }, -1)); - } - - [TestMethod] - public void RepeatSequence1() - { - var i = 0; - var xs = new[] { 1, 2 }.Do(_ => i++).Repeat(); - - var res = xs.Take(10).ToList(); - Assert.AreEqual(10, res.Count); - Assert.IsTrue(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3)); - Assert.AreEqual(10, i); - } - - [TestMethod] - public void RepeatSequence2() - { - var i = 0; - var xs = new[] { 1, 2 }.Do(_ => i++).Repeat(5); - - var res = xs.ToList(); - Assert.AreEqual(10, res.Count); - Assert.IsTrue(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3)); - Assert.AreEqual(10, i); - } - } -} diff --git a/Ix/Tests/Tests.Exceptions.cs b/Ix/Tests/Tests.Exceptions.cs deleted file mode 100644 index 38cabe4..0000000 --- a/Ix/Tests/Tests.Exceptions.cs +++ /dev/null @@ -1,311 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void Catch_Arguments() - { - AssertThrows(() => EnumerableEx.Catch(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.Catch(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.Catch(default(IEnumerable[]))); - AssertThrows(() => EnumerableEx.Catch(default(IEnumerable>))); - AssertThrows(() => EnumerableEx.Catch(null, ex => new[] { 1 })); - AssertThrows(() => EnumerableEx.Catch(new[] { 1 }, null)); - } - - [TestMethod] - public void Catch1() - { - var ex = new MyException(); - var res = EnumerableEx.Throw(ex).Catch(e => { Assert.AreSame(ex, e); return new[] { 42 }; }).Single(); - Assert.AreEqual(42, res); - } - - [TestMethod] - public void Catch2() - { - var ex = new MyException(); - var res = EnumerableEx.Throw(ex).Catch(e => { Assert.AreSame(ex, e); return new[] { 42 }; }).Single(); - Assert.AreEqual(42, res); - } - - [TestMethod] - public void Catch3() - { - var ex = new MyException(); - AssertThrows(() => - { - EnumerableEx.Throw(ex).Catch(e => { Assert.Fail(); return new[] { 42 }; }).Single(); - }); - } - - [TestMethod] - public void Catch4() - { - var xs = Enumerable.Range(0, 10); - var res = xs.Catch(e => { Assert.Fail(); return new[] { 42 }; }); - Assert.IsTrue(xs.SequenceEqual(res)); - } - - [TestMethod] - public void Catch5() - { - var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) }; - var res = EnumerableEx.Catch(xss); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5))); - } - - [TestMethod] - public void Catch6() - { - var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) }; - var res = xss.Catch(); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5))); - } - - [TestMethod] - public void Catch7() - { - var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) }; - var res = xss[0].Catch(xss[1]); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5))); - } - - [TestMethod] - public void Catch8() - { - var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw(new MyException())), Enumerable.Range(5, 5) }; - var res = EnumerableEx.Catch(xss); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); - } - - [TestMethod] - public void Catch9() - { - var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw(new MyException())), Enumerable.Range(5, 5) }; - var res = xss.Catch(); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); - } - - [TestMethod] - public void Catch10() - { - var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw(new MyException())), Enumerable.Range(5, 5) }; - var res = xss[0].Catch(xss[1]); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); - } - - [TestMethod] - public void Catch11() - { - var e1 = new MyException(); - var ex1 = EnumerableEx.Throw(e1); - - var e2 = new MyException(); - var ex2 = EnumerableEx.Throw(e2); - - var e3 = new MyException(); - var ex3 = EnumerableEx.Throw(e3); - - var xss = new[] { Enumerable.Range(0, 2).Concat(ex1), Enumerable.Range(2, 2).Concat(ex2), ex3 }; - var res = xss.Catch(); - - var e = res.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 1); - HasNext(e, 2); - HasNext(e, 3); - AssertThrows(() => e.MoveNext(), ex => ex == e3); - } - - [TestMethod] - public void Finally_Arguments() - { - AssertThrows(() => EnumerableEx.Finally(null, () => { })); - AssertThrows(() => EnumerableEx.Finally(new[] { 1 }, null)); - } - - [TestMethod] - public void Finally1() - { - var done = false; - - var xs = Enumerable.Range(0, 2).Finally(() => done = true); - Assert.IsFalse(done); - - var e = xs.GetEnumerator(); - Assert.IsFalse(done); - - HasNext(e, 0); - Assert.IsFalse(done); - - HasNext(e, 1); - Assert.IsFalse(done); - - NoNext(e); - Assert.IsTrue(done); - } - - [TestMethod] - public void Finally2() - { - var done = false; - - var xs = Enumerable.Range(0, 2).Finally(() => done = true); - Assert.IsFalse(done); - - var e = xs.GetEnumerator(); - Assert.IsFalse(done); - - HasNext(e, 0); - Assert.IsFalse(done); - - e.Dispose(); - Assert.IsTrue(done); - } - - [TestMethod] - public void Finally3() - { - var done = false; - - var ex = new MyException(); - var xs = EnumerableEx.Throw(ex).Finally(() => done = true); - Assert.IsFalse(done); - - var e = xs.GetEnumerator(); - Assert.IsFalse(done); - - try - { - HasNext(e, 0); - Assert.Fail(); - } - catch (MyException ex_) - { - Assert.AreSame(ex, ex_); - } - - Assert.IsTrue(done); - } - - [TestMethod] - public void OnErrorResumeNext_Arguments() - { - AssertThrows(() => EnumerableEx.OnErrorResumeNext(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.OnErrorResumeNext(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.OnErrorResumeNext(default(IEnumerable[]))); - AssertThrows(() => EnumerableEx.OnErrorResumeNext(default(IEnumerable>))); - } - - [TestMethod] - public void OnErrorResumeNext1() - { - var xs = new[] { 1, 2 }; - var ys = new[] { 3, 4 }; - - var res = xs.OnErrorResumeNext(ys); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); - } - - [TestMethod] - public void OnErrorResumeNext2() - { - var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw(new MyException())); - var ys = new[] { 3, 4 }; - - var res = xs.OnErrorResumeNext(ys); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); - } - - [TestMethod] - public void OnErrorResumeNext3() - { - var xs = new[] { 1, 2 }; - var ys = new[] { 3, 4 }; - var zs = new[] { 5, 6 }; - - var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 })); - } - - [TestMethod] - public void OnErrorResumeNext4() - { - var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw(new MyException())); - var ys = new[] { 3, 4 }; - var zs = new[] { 5, 6 }; - - var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 })); - } - - [TestMethod] - public void OnErrorResumeNext5() - { - var xs = new[] { 1, 2 }; - var ys = new[] { 3, 4 }; - - var res = new[] { xs, ys }.OnErrorResumeNext(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); - } - - [TestMethod] - public void OnErrorResumeNext6() - { - var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw(new MyException())); - var ys = new[] { 3, 4 }; - - var res = new[] { xs, ys }.OnErrorResumeNext(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); - } - - [TestMethod] - public void Retry_Arguments() - { - AssertThrows(() => EnumerableEx.Retry(null)); - AssertThrows(() => EnumerableEx.Retry(null, 5)); - AssertThrows(() => EnumerableEx.Retry(new[] { 1 }, -1)); - } - - [TestMethod] - public void Retry1() - { - var xs = Enumerable.Range(0, 10); - - var res = xs.Retry(); - Assert.IsTrue(Enumerable.SequenceEqual(res, xs)); - } - - [TestMethod] - public void Retry2() - { - var xs = Enumerable.Range(0, 10); - - var res = xs.Retry(2); - Assert.IsTrue(Enumerable.SequenceEqual(res, xs)); - } - - [TestMethod] - public void Retry3() - { - var ex = new MyException(); - var xs = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw(ex)); - - var res = xs.Retry(2); - var e = res.GetEnumerator(); - HasNext(e, 0); - HasNext(e, 1); - HasNext(e, 0); - HasNext(e, 1); - AssertThrows(() => e.MoveNext(), ex_ => ex == ex_); - } - } -} diff --git a/Ix/Tests/Tests.Imperative.cs b/Ix/Tests/Tests.Imperative.cs deleted file mode 100644 index 3b038c6..0000000 --- a/Ix/Tests/Tests.Imperative.cs +++ /dev/null @@ -1,180 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void While_Arguments() - { - AssertThrows(() => EnumerableEx.While(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.While(() => true, null)); - } - - [TestMethod] - public void While1() - { - var x = 5; - var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 })); - } - - [TestMethod] - public void While2() - { - var x = 0; - var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new int[0])); - } - - [TestMethod] - public void DoWhile_Arguments() - { - AssertThrows(() => EnumerableEx.DoWhile(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.DoWhile(null, () => true)); - } - - [TestMethod] - public void DoWhile1() - { - var x = 5; - var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 })); - } - - [TestMethod] - public void DoWhile2() - { - var x = 0; - var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0 })); - } - - [TestMethod] - public void If_Arguments() - { - AssertThrows(() => EnumerableEx.If(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.If(() => true, null)); - AssertThrows(() => EnumerableEx.If(null, new[] { 1 }, new[] { 1 })); - AssertThrows(() => EnumerableEx.If(() => true, null, new[] { 1 })); - AssertThrows(() => EnumerableEx.If(() => true, new[] { 1 }, null)); - } - - [TestMethod] - public void If1() - { - var x = 5; - var res = EnumerableEx.If(() => x > 0, new[] { +1 }, new[] { -1 }); - - Assert.AreEqual(+1, res.Single()); - - x = -x; - Assert.AreEqual(-1, res.Single()); - } - - [TestMethod] - public void If2() - { - var x = 5; - var res = EnumerableEx.If(() => x > 0, new[] { +1 }); - - Assert.AreEqual(+1, res.Single()); - - x = -x; - Assert.IsTrue(res.IsEmpty()); - } - - [TestMethod] - public void Case_Arguments() - { - AssertThrows(() => EnumerableEx.Case(null, new Dictionary>())); - AssertThrows(() => EnumerableEx.Case(() => 1, null)); - AssertThrows(() => EnumerableEx.Case(null, new Dictionary>(), new[] { 1 })); - AssertThrows(() => EnumerableEx.Case(() => 1, null, new[] { 1 })); - AssertThrows(() => EnumerableEx.Case(() => 1, new Dictionary>(), null)); - } - - [TestMethod] - public void Case1() - { - var x = 1; - var d = 'd'; - var res = EnumerableEx.Case(() => x, new Dictionary> - { - { 0, new[] { 'a' } }, - { 1, new[] { 'b' } }, - { 2, new[] { 'c' } }, - { 3, EnumerableEx.Defer(() => new[] { d }) }, - }); - - Assert.AreEqual('b', res.Single()); - Assert.AreEqual('b', res.Single()); - - x = 0; - Assert.AreEqual('a', res.Single()); - - x = 2; - Assert.AreEqual('c', res.Single()); - - x = 3; - Assert.AreEqual('d', res.Single()); - - d = 'e'; - Assert.AreEqual('e', res.Single()); - - x = 4; - Assert.IsTrue(res.IsEmpty()); - } - - [TestMethod] - public void Case2() - { - var x = 1; - var d = 'd'; - var res = EnumerableEx.Case(() => x, new Dictionary> - { - { 0, new[] { 'a' } }, - { 1, new[] { 'b' } }, - { 2, new[] { 'c' } }, - { 3, EnumerableEx.Defer(() => new[] { d }) }, - }, new[] { 'z' }); - - Assert.AreEqual('b', res.Single()); - Assert.AreEqual('b', res.Single()); - - x = 0; - Assert.AreEqual('a', res.Single()); - - x = 2; - Assert.AreEqual('c', res.Single()); - - x = 3; - Assert.AreEqual('d', res.Single()); - - d = 'e'; - Assert.AreEqual('e', res.Single()); - - x = 4; - Assert.AreEqual('z', res.Single()); - } - - [TestMethod] - public void For_Arguments() - { - AssertThrows(() => EnumerableEx.For(null, x => new[] { 1 })); - AssertThrows(() => EnumerableEx.For(new[] { 1 }, null)); - } - - [TestMethod] - public void For() - { - var res = EnumerableEx.For(new[] { 1, 2, 3 }, x => Enumerable.Range(0, x)).ToList(); - Assert.IsTrue(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2 })); - } - } -} diff --git a/Ix/Tests/Tests.Multiple.cs b/Ix/Tests/Tests.Multiple.cs deleted file mode 100644 index 3df8927..0000000 --- a/Ix/Tests/Tests.Multiple.cs +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void Concat_Arguments() - { - AssertThrows(() => EnumerableEx.Concat(default(IEnumerable[]))); - AssertThrows(() => EnumerableEx.Concat(default(IEnumerable>))); - } - - [TestMethod] - public void Concat1() - { - var res = new[] - { - new[] { 1, 2, 3 }, - new[] { 4, 5 } - }.Concat(); - - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 })); - } - - [TestMethod] - public void Concat2() - { - var i = 0; - var xss = Enumerable.Range(0, 3).Select(x => Enumerable.Range(0, x + 1)).Do(_ => ++i); - - var res = xss.Concat().Select(x => i + " - " + x).ToList(); - - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { - "1 - 0", - "2 - 0", - "2 - 1", - "3 - 0", - "3 - 1", - "3 - 2", - })); - } - - [TestMethod] - public void Concat3() - { - var res = EnumerableEx.Concat( - new[] { 1, 2, 3 }, - new[] { 4, 5 } - ); - - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 })); - } - - [TestMethod] - public void SelectMany_Arguments() - { - AssertThrows(() => EnumerableEx.SelectMany(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.SelectMany(new[] { 1 }, null)); - } - - [TestMethod] - public void SelectMany() - { - var res = new[] { 1, 2 }.SelectMany(new[] { 'a', 'b', 'c' }).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 'a', 'b', 'c', 'a', 'b', 'c' })); - } - } -} diff --git a/Ix/Tests/Tests.Qbservable.cs b/Ix/Tests/Tests.Qbservable.cs deleted file mode 100644 index d174eee..0000000 --- a/Ix/Tests/Tests.Qbservable.cs +++ /dev/null @@ -1,139 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if !SILVERLIGHTM7 - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Reflection; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Runtime.CompilerServices; -using System.Linq.Expressions; -using System.ComponentModel; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void Queryable_Enumerable_Parity() - { - var enu = typeof(EnumerableEx).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList(); - var qry = typeof(QueryableEx).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList(); - - var onlyInObs = enu.Select(m => m.Name).Except(qry.Select(m => m.Name)).Except(new[] { "ForEach", "ToEnumerable", "Multicast", "GetAwaiter", "ToEvent", "ToEventPattern", "ForEachAsync" }).ToList(); - var onlyInQbs = qry.Select(m => m.Name).Except(enu.Select(m => m.Name)).Except(new[] { "ToQueryable", "get_Provider", "Empty", "Range" }).ToList(); - - Assert.IsTrue(onlyInObs.Count == 0, "Missing Queryable operator: " + string.Join(", ", onlyInObs.ToArray())); - Assert.IsTrue(onlyInQbs.Count == 0, "Missing Enumerable operator: " + string.Join(", ", onlyInQbs.ToArray())); - - var enus = enu.GroupBy(m => m.Name); - var qrys = qry.GroupBy(m => m.Name); - var mtch = (from o in enus - join q in qrys on o.Key equals q.Key - select new { Name = o.Key, Enumerable = o.ToList(), Queryable = q.ToList() }) - .ToList(); - - Func filterReturn = t => - { - if (t.IsGenericType) - { - var gd = t.GetGenericTypeDefinition(); - if (gd == typeof(IBuffer<>)) - return false; - } - return true; - }; - - Func filterHelper = m => - { - return !m.IsDefined(typeof(EditorBrowsableAttribute), false); - }; - - foreach (var group in mtch) - { - var oss = group.Enumerable.Where(m => filterReturn(m.ReturnType)).Select(m => GetSignature(m, false)).OrderBy(x => x).ToList(); - var qss = group.Queryable.Where(m => filterHelper(m)).Select(m => GetSignature(m, true)).OrderBy(x => x).ToList(); - - Assert.IsTrue(oss.SequenceEqual(qss), "Mismatch between QueryableEx and EnumerableEx for " + group.Name); - } - } - - public static string GetSignature(MethodInfo m, bool correct) - { - var ps = m.GetParameters(); - var pss = ps.AsEnumerable(); - if (correct && ps.Length > 0 && ps[0].ParameterType == typeof(IQueryProvider)) - pss = pss.Skip(1); - - var gens = m.IsGenericMethod ? string.Format("<{0}>", string.Join(", ", m.GetGenericArguments().Select(a => GetTypeName(a, correct)).ToArray())) : ""; - - var pars = string.Join(", ", pss.Select(p => (Attribute.IsDefined(p, typeof(ParamArrayAttribute)) ? "params " : "") + GetTypeName(p.ParameterType, correct) + " " + p.Name).ToArray()); - if (Attribute.IsDefined(m, typeof(ExtensionAttribute))) - { - if (pars.StartsWith("IQbservable") || pars.StartsWith("IQueryable")) - pars = "this " + pars; - } - - return string.Format("{0} {1}{2}({3})", GetTypeName(m.ReturnType, correct), m.Name, gens, pars); - } - - public static string GetTypeName(Type t, bool correct) - { - if (t.IsGenericType) - { - var gtd = t.GetGenericTypeDefinition(); - if (gtd == typeof(Expression<>)) - return GetTypeName(t.GetGenericArguments()[0], false); - - var args = string.Join(", ", t.GetGenericArguments().Select(a => GetTypeName(a, false)).ToArray()); - - var len = t.Name.IndexOf('`'); - var name = len >= 0 ? t.Name.Substring(0, len) : t.Name; - if (correct && name == "IQbservable") - name = "IObservable"; - if (correct && name == "IQueryable") - name = "IEnumerable"; - - return string.Format("{0}<{1}>", name, args); - } - - if (t.IsArray) - { - return GetTypeName(t.GetElementType(), correct) + "[]"; - } - - return t.Name; - } - - [TestMethod] - public void QueryableRetarget1() - { - var res = QueryableEx.Provider.Empty().AsEnumerable().ToList(); - Assert.IsTrue(res.SequenceEqual(new int[0])); - } - - [TestMethod] - public void QueryableRetarget2() - { - var res = QueryableEx.Provider.Return(42).AsEnumerable().ToList(); - Assert.IsTrue(res.SequenceEqual(new[] { 42 })); - } - - [TestMethod] - public void QueryableRetarget3() - { - var res = Enumerable.Range(0, 10).AsQueryable().TakeLast(2).AsEnumerable().ToList(); - Assert.IsTrue(res.SequenceEqual(new[] { 8, 9 })); - } - - [TestMethod] - public void QueryableRetarget4() - { - var res = QueryableEx.Provider.Range(0, 10).AsEnumerable().ToList(); - Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10))); - } - } -} - -#endif \ No newline at end of file diff --git a/Ix/Tests/Tests.Single.cs b/Ix/Tests/Tests.Single.cs deleted file mode 100644 index 6054f54..0000000 --- a/Ix/Tests/Tests.Single.cs +++ /dev/null @@ -1,431 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - public partial class Tests - { - [TestMethod] - public void Hide_Arguments() - { - AssertThrows(() => EnumerableEx.Hide(null)); - } - - [TestMethod] - public void Hide() - { - var xs = new List { 1, 2, 3 }; - var ys = xs.Hide(); - Assert.IsFalse(ys is List); - Assert.IsTrue(xs.SequenceEqual(ys)); - } - - [TestMethod] - public void ForEach_Arguments() - { - AssertThrows(() => EnumerableEx.ForEach(null, x => { })); - AssertThrows(() => EnumerableEx.ForEach(new[] { 1 }, default(Action))); - AssertThrows(() => EnumerableEx.ForEach(null, (x, i) => { })); - AssertThrows(() => EnumerableEx.ForEach(new[] { 1 }, default(Action))); - } - - [TestMethod] - public void ForEach1() - { - var n = 0; - Enumerable.Range(5, 3).ForEach(x => n += x); - Assert.AreEqual(5 + 6 + 7, n); - } - - [TestMethod] - public void ForEach2() - { - var n = 0; - Enumerable.Range(5, 3).ForEach((x, i) => n += x * i); - Assert.AreEqual(5 * 0 + 6 * 1 + 7 * 2, n); - } - - [TestMethod] - public void Buffer_Arguments() - { - AssertThrows(() => EnumerableEx.Buffer(null, 5)); - AssertThrows(() => EnumerableEx.Buffer(null, 5, 3)); - AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 0)); - AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 5, 0)); - AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 0, 3)); - } - - [TestMethod] - public void Buffer1() - { - var rng = Enumerable.Range(0, 10); - - var res = rng.Buffer(3).ToList(); - Assert.AreEqual(4, res.Count); - - Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 })); - Assert.IsTrue(res[1].SequenceEqual(new[] { 3, 4, 5 })); - Assert.IsTrue(res[2].SequenceEqual(new[] { 6, 7, 8 })); - Assert.IsTrue(res[3].SequenceEqual(new[] { 9 })); - } - - [TestMethod] - public void Buffer2() - { - var rng = Enumerable.Range(0, 10); - - var res = rng.Buffer(5).ToList(); - Assert.AreEqual(2, res.Count); - - Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2, 3, 4 })); - Assert.IsTrue(res[1].SequenceEqual(new[] { 5, 6, 7, 8, 9 })); - } - - [TestMethod] - public void Buffer3() - { - var rng = Enumerable.Empty(); - - var res = rng.Buffer(5).ToList(); - Assert.AreEqual(0, res.Count); - } - - [TestMethod] - public void Buffer4() - { - var rng = Enumerable.Range(0, 10); - - var res = rng.Buffer(3, 2).ToList(); - Assert.AreEqual(5, res.Count); - - Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 })); - Assert.IsTrue(res[1].SequenceEqual(new[] { 2, 3, 4 })); - Assert.IsTrue(res[2].SequenceEqual(new[] { 4, 5, 6 })); - Assert.IsTrue(res[3].SequenceEqual(new[] { 6, 7, 8 })); - Assert.IsTrue(res[4].SequenceEqual(new[] { 8, 9 })); - } - - [TestMethod] - public void Buffer5() - { - var rng = Enumerable.Range(0, 10); - - var res = rng.Buffer(3, 4).ToList(); - Assert.AreEqual(3, res.Count); - - Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 })); - Assert.IsTrue(res[1].SequenceEqual(new[] { 4, 5, 6 })); - Assert.IsTrue(res[2].SequenceEqual(new[] { 8, 9 })); - } - - [TestMethod] - public void Do_Arguments() - { - AssertThrows(() => EnumerableEx.Do(null, _ => { })); - AssertThrows(() => EnumerableEx.Do(null, _ => { }, () => { })); - AssertThrows(() => EnumerableEx.Do(null, _ => { }, _ => { })); - AssertThrows(() => EnumerableEx.Do(null, _ => { }, _ => { }, () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action))); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action))); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), _ => { }, () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action), () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, _ => { }, default(Action))); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), _ => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action))); -#if !NO_RXINTERFACES - AssertThrows(() => EnumerableEx.Do(null, new MyObserver())); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(IObserver))); -#endif - } - - [TestMethod] - public void Do1() - { - var n = 0; - Enumerable.Range(0, 10).Do(x => n += x).ForEach(_ => { }); - Assert.AreEqual(45, n); - } - - [TestMethod] - public void Do2() - { - var n = 0; - Enumerable.Range(0, 10).Do(x => n += x, () => n *= 2).ForEach(_ => { }); - Assert.AreEqual(90, n); - } - - [TestMethod] - public void Do3() - { - var ex = new MyException(); - var ok = false; - AssertThrows(() => - EnumerableEx.Throw(ex).Do(x => { Assert.Fail(); }, e => { Assert.AreEqual(ex, e); ok = true; }).ForEach(_ => { }) - ); - Assert.IsTrue(ok); - } - -#if !NO_RXINTERFACES - [TestMethod] - public void Do4() - { - var obs = new MyObserver(); - Enumerable.Range(0, 10).Do(obs).ForEach(_ => { }); - - Assert.IsTrue(obs.Done); - Assert.AreEqual(45, obs.Sum); - } - - class MyObserver : IObserver - { - public int Sum; - public bool Done; - - public void OnCompleted() - { - Done = true; - } - - public void OnError(Exception error) - { - throw new NotImplementedException(); - } - - public void OnNext(int value) - { - Sum += value; - } - } -#endif - - [TestMethod] - public void Do5() - { - var sum = 0; - var done = false; - Enumerable.Range(0, 10).Do(x => sum += x, ex => { throw ex; }, () => done = true).ForEach(_ => { }); - - Assert.IsTrue(done); - Assert.AreEqual(45, sum); - } - - [TestMethod] - public void StartWith_Arguments() - { - AssertThrows(() => EnumerableEx.StartWith(null, 5)); - } - - [TestMethod] - public void StartWith1() - { - var e = Enumerable.Range(1, 5); - var r = e.StartWith(0).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, Enumerable.Range(0, 6))); - } - - [TestMethod] - public void StartWith2() - { - var oops = false; - var e = Enumerable.Range(1, 5).Do(_ => oops = true); - var r = e.StartWith(0).Take(1).ToList(); - Assert.IsFalse(oops); - } - - [TestMethod] - public void Expand_Arguments() - { - AssertThrows(() => EnumerableEx.Expand(null, _ => new[] { _ })); - AssertThrows(() => EnumerableEx.Expand(new[] { 1 }, null)); - } - - [TestMethod] - public void Expand1() - { - var res = new[] { 0 }.Expand(x => new[] { x + 1 }).Take(10).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, Enumerable.Range(0, 10))); - } - - [TestMethod] - public void Expand2() - { - var res = new[] { 3 }.Expand(x => Enumerable.Range(0, x)).ToList(); - var exp = new[] { - 3, - 0, 1, 2, - 0, - 0, 1, - 0 - }; - Assert.IsTrue(Enumerable.SequenceEqual(res, exp)); - } - - [TestMethod] - public void Distinct_Arguments() - { - AssertThrows(() => EnumerableEx.Distinct(null, _ => _)); - AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.Distinct(null, _ => _, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, null, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, _ => _, null)); - } - - [TestMethod] - public void Distinct1() - { - var res = Enumerable.Range(0, 10).Distinct(x => x % 5).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, Enumerable.Range(0, 5))); - } - - [TestMethod] - public void Distinct2() - { - var res = Enumerable.Range(0, 10).Distinct(x => x % 5, new MyEqualityComparer()).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0, 1 })); - } - - class MyEqualityComparer : IEqualityComparer - { - public bool Equals(int x, int y) - { - return x % 2 == y % 2; - } - - public int GetHashCode(int obj) - { - return EqualityComparer.Default.GetHashCode(obj % 2); - } - } - - [TestMethod] - public void DistinctUntilChanged_Arguments() - { - AssertThrows(() => EnumerableEx.DistinctUntilChanged(null)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, _ => _)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, _ => _, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, _ => _, null)); - } - - [TestMethod] - public void DistinctUntilChanged1() - { - var res = new[] { 1, 2, 2, 3, 3, 3, 2, 2, 1 }.DistinctUntilChanged().ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 2, 1 })); - } - - [TestMethod] - public void DistinctUntilChanged2() - { - var res = new[] { 1, 1, 2, 3, 4, 5, 5, 6, 7 }.DistinctUntilChanged(x => x / 2).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 4, 6 })); - } - - [TestMethod] - public void IgnoreElements_Arguments() - { - AssertThrows(() => EnumerableEx.IgnoreElements(null)); - } - - [TestMethod] - public void IgnoreElements() - { - var n = 0; - Enumerable.Range(0, 10).Do(_ => n++).IgnoreElements().Take(5).ForEach(_ => { }); - Assert.AreEqual(10, n); - } - - [TestMethod] - public void TakeLast_Arguments() - { - AssertThrows(() => EnumerableEx.TakeLast(null, 5)); - AssertThrows(() => EnumerableEx.TakeLast(new[] { 1 }, -1)); - } - - [TestMethod] - public void TakeLast_Empty() - { - var e = Enumerable.Empty(); - var r = e.TakeLast(1).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, e)); - } - - [TestMethod] - public void TakeLast_All() - { - var e = Enumerable.Range(0, 5); - var r = e.TakeLast(5).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, e)); - } - - [TestMethod] - public void TakeLast_Part() - { - var e = Enumerable.Range(0, 5); - var r = e.TakeLast(3).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, e.Skip(2))); - } - - [TestMethod] - public void SkipLast_Arguments() - { - AssertThrows(() => EnumerableEx.SkipLast(null, 5)); - AssertThrows(() => EnumerableEx.SkipLast(new[] { 1 }, -1)); - } - - [TestMethod] - public void SkipLast_Empty() - { - var e = Enumerable.Empty(); - var r = e.SkipLast(1).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, e)); - } - - [TestMethod] - public void SkipLast_All() - { - var e = Enumerable.Range(0, 5); - var r = e.SkipLast(0).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, e)); - } - - [TestMethod] - public void SkipLast_Part() - { - var e = Enumerable.Range(0, 5); - var r = e.SkipLast(3).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(r, e.Take(2))); - } - - [TestMethod] - public void Scan_Arguments() - { - AssertThrows(() => EnumerableEx.Scan(null, (x, y) => x + y)); - AssertThrows(() => EnumerableEx.Scan(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.Scan(null, 0, (x, y) => x + y)); - AssertThrows(() => EnumerableEx.Scan(new[] { 1 }, 0, null)); - } - - [TestMethod] - public void Scan1() - { - var res = Enumerable.Range(0, 5).Scan((n, x) => n + x).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 3, 6, 10 })); - } - - [TestMethod] - public void Scan2() - { - var res = Enumerable.Range(0, 5).Scan(10, (n, x) => n - x).ToList(); - Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 10, 9, 7, 4, 0 })); - } - } -} diff --git a/Ix/Tests/Tests.cs b/Ix/Tests/Tests.cs deleted file mode 100644 index 27dca14..0000000 --- a/Ix/Tests/Tests.cs +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace Tests -{ - [TestClass] - public partial class Tests - { - public void AssertThrows(Action a) - where E : Exception - { - try - { - a(); - Assert.Fail(); - } - catch (E) - { - } - } - - public void AssertThrows(Action a, Func assert) - where E : Exception - { - try - { - a(); - Assert.Fail(); - } - catch (E e) - { - Assert.IsTrue(assert(e)); - } - } - - public void NoNext(IEnumerator e) - { - Assert.IsFalse(e.MoveNext()); - } - - public void HasNext(IEnumerator e, T value) - { - Assert.IsTrue(e.MoveNext()); - Assert.AreEqual(value, e.Current); - } - } -} diff --git a/Ix/Tests/Tests.csproj b/Ix/Tests/Tests.csproj deleted file mode 100644 index f3f57ff..0000000 --- a/Ix/Tests/Tests.csproj +++ /dev/null @@ -1,91 +0,0 @@ - - - - Debug - AnyCPU - - - 2.0 - {C4C8532A-F8D2-428B-962E-FD578A1E647C} - Library - Properties - Tests - Tests - v4.0 - 512 - {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} - - - - true - true - $(AssemblyName).xap - true - Properties\AppManifest.xml - InteractiveTests.App - TestPage.html - true - - - - _$(AssemblyName) - - - - - ..\..\..\..\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll - - - - - - - - - true - - - - - - - False - - - - - - - - - - - - - - - - - - - - - - - - - - {7269A578-326A-4C3E-9874-A2D2600095BC} - System.Interactive.Async - - - {6D62E966-469D-4A99-BD43-0A17FA14FB4F} - System.Interactive.Providers - - - {8E4B04F0-915E-48F9-9796-76278C6094BD} - System.Interactive - - - - \ No newline at end of file diff --git a/Ix/TraceAndTestImpact.testsettings b/Ix/TraceAndTestImpact.testsettings deleted file mode 100644 index 363295b..0000000 --- a/Ix/TraceAndTestImpact.testsettings +++ /dev/null @@ -1,21 +0,0 @@ - - - These are test settings for Trace and Test Impact. - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/Rx++/.gitattributes b/Rx++/.gitattributes deleted file mode 100644 index 412eeda..0000000 --- a/Rx++/.gitattributes +++ /dev/null @@ -1,22 +0,0 @@ -# Auto detect text files and perform LF normalization -* text=auto - -# Custom for Visual Studio -*.cs diff=csharp -*.sln merge=union -*.csproj merge=union -*.vbproj merge=union -*.fsproj merge=union -*.dbproj merge=union - -# Standard to msysgit -*.doc diff=astextplain -*.DOC diff=astextplain -*.docx diff=astextplain -*.DOCX diff=astextplain -*.dot diff=astextplain -*.DOT diff=astextplain -*.pdf diff=astextplain -*.PDF diff=astextplain -*.rtf diff=astextplain -*.RTF diff=astextplain diff --git a/Rx++/.gitignore b/Rx++/.gitignore deleted file mode 100644 index 5ebd21a..0000000 --- a/Rx++/.gitignore +++ /dev/null @@ -1,163 +0,0 @@ -################# -## Eclipse -################# - -*.pydevproject -.project -.metadata -bin/ -tmp/ -*.tmp -*.bak -*.swp -*~.nib -local.properties -.classpath -.settings/ -.loadpath - -# External tool builders -.externalToolBuilders/ - -# Locally stored "Eclipse launch configurations" -*.launch - -# CDT-specific -.cproject - -# PDT-specific -.buildpath - - -################# -## Visual Studio -################# - -## Ignore Visual Studio temporary files, build results, and -## files generated by popular Visual Studio add-ons. - -# User-specific files -*.suo -*.user -*.sln.docstates - -# Build results -[Dd]ebug/ -[Rr]elease/ -*_i.c -*_p.c -*.ilk -*.meta -*.obj -*.pch -*.pdb -*.pgc -*.pgd -*.rsp -*.sbr -*.tlb -*.tli -*.tlh -*.tmp -*.vspscc -.builds -*.dotCover - -## TODO: If you have NuGet Package Restore enabled, uncomment this -#packages/ - -# Visual C++ cache files -ipch/ -*.aps -*.ncb -*.opensdf -*.sdf - -# Visual Studio profiler -*.psess -*.vsp - -# ReSharper is a .NET coding add-in -_ReSharper* - -# Installshield output folder -[Ee]xpress - -# DocProject is a documentation generator add-in -DocProject/buildhelp/ -DocProject/Help/*.HxT -DocProject/Help/*.HxC -DocProject/Help/*.hhc -DocProject/Help/*.hhk -DocProject/Help/*.hhp -DocProject/Help/Html2 -DocProject/Help/html - -# Click-Once directory -publish - -# Others -[Bb]in -[Oo]bj -sql -TestResults -*.Cache -ClientBin -stylecop.* -~$* -*.dbmdl -Generated_Code #added for RIA/Silverlight projects - -# Backup & report files from converting an old project file to a newer -# Visual Studio version. Backup files are not needed, because we have git ;-) -_UpgradeReport_Files/ -Backup*/ -UpgradeLog*.XML - - - -############ -## Windows -############ - -# Windows image file caches -Thumbs.db - -# Folder config file -Desktop.ini - - -############# -## Python -############# - -*.py[co] - -# Packages -*.egg -*.egg-info -dist -build -eggs -parts -bin -var -sdist -develop-eggs -.installed.cfg - -# Installer logs -pip-log.txt - -# Unit test / coverage reports -.coverage -.tox - -#Translations -*.mo - -#Mr Developer -.mr.developer.cfg - -# Mac crap -.DS_Store diff --git a/Rx++/license.txt b/Rx++/license.txt deleted file mode 100644 index 5b47fbd..0000000 --- a/Rx++/license.txt +++ /dev/null @@ -1,15 +0,0 @@ -Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. -Microsoft Open Technologies would like to thank its contributors, a list -of whom are at http://rx.codeplex.com/wikipage?title=Contributors. - -Licensed under the Apache License, Version 2.0 (the "License"); you -may not use this file except in compliance with the License. You may -obtain a copy of the License at - -http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -implied. See the License for the specific language governing permissions -and limitations under the License. \ No newline at end of file diff --git a/Ix/.gitattributes b/Rx/CPP/.gitattributes similarity index 100% rename from Ix/.gitattributes rename to Rx/CPP/.gitattributes diff --git a/Ix/.gitignore b/Rx/CPP/.gitignore similarity index 100% rename from Ix/.gitignore rename to Rx/CPP/.gitignore diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MainFrm.cpp rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MainFrm.h rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj diff --git a/Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters rename to Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters diff --git a/Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt b/Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/ReadMe.txt rename to Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt diff --git a/Rx++/MfcTimeFliesLikeAnArrow/Resource.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/Resource.h rename to Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h diff --git a/Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico b/Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico rename to Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico diff --git a/Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 b/Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 rename to Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 diff --git a/Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/stdafx.cpp rename to Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp diff --git a/Rx++/MfcTimeFliesLikeAnArrow/stdafx.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/stdafx.h rename to Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h diff --git a/Rx++/MfcTimeFliesLikeAnArrow/targetver.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h similarity index 100% rename from Rx++/MfcTimeFliesLikeAnArrow/targetver.h rename to Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h diff --git a/Rx++/RxCpp.sln b/Rx/CPP/RxCpp.sln similarity index 100% rename from Rx++/RxCpp.sln rename to Rx/CPP/RxCpp.sln diff --git a/Ix/license.txt b/Rx/CPP/license.txt similarity index 100% rename from Ix/license.txt rename to Rx/CPP/license.txt diff --git a/Rx++/testbench/rxcpp-binder.h b/Rx/CPP/testbench/rxcpp-binder.h similarity index 100% rename from Rx++/testbench/rxcpp-binder.h rename to Rx/CPP/testbench/rxcpp-binder.h diff --git a/Rx++/testbench/rxcpp.h b/Rx/CPP/testbench/rxcpp.h similarity index 100% rename from Rx++/testbench/rxcpp.h rename to Rx/CPP/testbench/rxcpp.h diff --git a/Rx++/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp similarity index 100% rename from Rx++/testbench/testbench.cpp rename to Rx/CPP/testbench/testbench.cpp diff --git a/Rx++/testbench/testbench.vcxproj b/Rx/CPP/testbench/testbench.vcxproj similarity index 100% rename from Rx++/testbench/testbench.vcxproj rename to Rx/CPP/testbench/testbench.vcxproj diff --git a/Rx++/testbench/testbench.vcxproj.filters b/Rx/CPP/testbench/testbench.vcxproj.filters similarity index 100% rename from Rx++/testbench/testbench.vcxproj.filters rename to Rx/CPP/testbench/testbench.vcxproj.filters -- GitLab From e6a9df4ff6a4e3e9ab9fc5dcea4137d6dcf324ab Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 7 Feb 2013 01:11:48 -0800 Subject: [PATCH 009/782] Get the CPP linq sample compiling on clang 4.1 (OSX) --- .../samples/SampleCppLinq/SampleCppLinq.cpp | 8 +++---- Ix/CPP/src/cpplinq/linq.hpp | 21 +++++++++++++++---- Ix/CPP/src/cpplinq/linq_iterators.hpp | 8 +++---- Ix/CPP/src/cpplinq/util.hpp | 13 ++++++++++-- 4 files changed, 36 insertions(+), 14 deletions(-) diff --git a/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp index e459e4b..3e6483e 100644 --- a/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp +++ b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp @@ -3,8 +3,6 @@ // SampleCppLinq.cpp : Defines the entry point for the console application. // -#include - #include #include #include @@ -16,6 +14,8 @@ #include #include +#include + using namespace std; vector load_data(); @@ -52,7 +52,7 @@ void run() for (auto giter = data.begin(), end = data.end(); giter != end; ++giter) { - auto& g = *giter; + const auto& g = *giter; cout << "arguments: " << g.key << endl; @@ -63,7 +63,7 @@ void run() for (auto giter = seq.begin(), end = seq.end(); giter != end; ++giter) { - auto& g = *giter; + const auto& g = *giter; cout << g.key << ", "; diff --git a/Ix/CPP/src/cpplinq/linq.hpp b/Ix/CPP/src/cpplinq/linq.hpp index 1070331..7a7f6c2 100644 --- a/Ix/CPP/src/cpplinq/linq.hpp +++ b/Ix/CPP/src/cpplinq/linq.hpp @@ -149,6 +149,15 @@ #define LINQ_USE_RTTI 1 #endif +#if defined(__clang__) +#if __has_feature(cxx_rvalue_references) +#define LINQ_USE_RVALUEREF 1 +#endif +#if __has_feature(cxx_rtti) +#define LINQ_USE_RTTI 1 +#endif +#endif + // individual features #include "util.hpp" @@ -242,7 +251,7 @@ public: template linq_driver< linq_where > where(Predicate p) const { - return typename linq_where(c, std::move(p) ); + return linq_where(c, std::move(p) ); } @@ -266,7 +275,7 @@ public: return std::accumulate(begin(), end(), initialValue, fn); } - bool any() const { return !empty(cur); } + bool any() const { auto cur = c.get_cursor(); return !cur.empty(); } template bool any(Predicate p) const { @@ -282,12 +291,16 @@ public: // TODO: average +#if !defined(__clang__) + // Clang complains that linq_driver is not complete until the closing brace + // so (linq_driver*)->select() cannot be resolved. template auto cast() -> decltype(static_cast(0)->select(detail::cast_to())) { return this->select(detail::cast_to()); } +#endif // TODO: concat @@ -295,12 +308,12 @@ public: return std::find(begin(), end(), value) != end(); } - typename std::iterator_traits::distance_type count() const { + typename std::iterator_traits::difference_type count() const { return std::distance(begin(), end()); } template - typename std::iterator_traits::distance_type count(Predicate p) const { + typename std::iterator_traits::difference_type count(Predicate p) const { auto filtered = this->where(p); return std::distance(begin(filtered), end(filtered)); } diff --git a/Ix/CPP/src/cpplinq/linq_iterators.hpp b/Ix/CPP/src/cpplinq/linq_iterators.hpp index ed267ec..a04b217 100644 --- a/Ix/CPP/src/cpplinq/linq_iterators.hpp +++ b/Ix/CPP/src/cpplinq/linq_iterators.hpp @@ -74,16 +74,16 @@ namespace cpplinq { namespace util { template typename std::iterator_traits::pointer deref_iterator(const Iter& it) { - return detail::deref_iterator(it, std::identity::reference>()); + return deref_iterator(it, util::identity::reference>()); } template - T* deref_iterator(const Iter& it, std::identity) { + T* deref_iterator(const Iter& it, util::identity) { return &*it; } template - util::value_ptr deref_iterator(const Iter& it, std::identity) { + util::value_ptr deref_iterator(const Iter& it, util::identity) { return util::value_ptr(*it); } } @@ -137,7 +137,7 @@ namespace cpplinq { return cur->get(); } - pointer operator->() const { + typename cursor_iterator::pointer operator->() const { auto& v = **this; return &v; } diff --git a/Ix/CPP/src/cpplinq/util.hpp b/Ix/CPP/src/cpplinq/util.hpp index 6fb62ff..f1e5222 100644 --- a/Ix/CPP/src/cpplinq/util.hpp +++ b/Ix/CPP/src/cpplinq/util.hpp @@ -104,17 +104,26 @@ namespace cpplinq { namespace util { detail::instance(), detail::instance())) type; }; -#else +#elif defined(_MSC_VER) template struct result_of : std::tr1::result_of {}; +#else + using std::result_of; #endif + template + struct identity + { + typedef Type type; + Type operator()(const Type& left) const {return left;} + }; + // faux pointer proxy for iterators that dereference to a value rather than reference, such as selectors template struct value_ptr { T value; - value_ptr(const T& pvalue) : value(value) + value_ptr(const T& value) : value(value) {} value_ptr(const T* pvalue) : value(*pvalue) {} -- GitLab From 58d879ed4e3b1224f37e3e8dd1f565379cdd21ae Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 7 Feb 2013 08:40:25 -0800 Subject: [PATCH 010/782] Restore the intended include dependencies clang commandline: clang++ -stdlib=libc++ -std=c++0x -I/Rx/rx/Ix/CPP/src/ SampleCppLinq.cpp --- Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp | 4 ++-- Ix/CPP/src/cpplinq/linq.hpp | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp index 3e6483e..4a1b499 100644 --- a/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp +++ b/Ix/CPP/samples/SampleCppLinq/SampleCppLinq.cpp @@ -3,6 +3,8 @@ // SampleCppLinq.cpp : Defines the entry point for the console application. // +#include + #include #include #include @@ -14,8 +16,6 @@ #include #include -#include - using namespace std; vector load_data(); diff --git a/Ix/CPP/src/cpplinq/linq.hpp b/Ix/CPP/src/cpplinq/linq.hpp index 7a7f6c2..2d7c1e7 100644 --- a/Ix/CPP/src/cpplinq/linq.hpp +++ b/Ix/CPP/src/cpplinq/linq.hpp @@ -131,6 +131,8 @@ #include #include +#include +#include #include #include #include -- GitLab From e703693c1b5c7e28c08d65007ed2c05de4675e44 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Feb 2013 14:19:55 -0800 Subject: [PATCH 011/782] publish Rx CPP a little more formally --- Ix/CPP/.gitignore | 7 +++- Rx/CPP/.gitignore | 2 ++ .../MfcTimeFliesLikeAnArrow.vcxproj | 4 +-- Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h | 2 +- .../rxcpp.h => src/cpprx/rx-base.hpp} | 29 ++-------------- .../rxcpp-binder.h => src/cpprx/rx.hpp} | 33 ++++++++++++++++++- Rx/CPP/testbench/testbench.cpp | 2 +- Rx/CPP/testbench/testbench.vcxproj | 6 ++-- 8 files changed, 49 insertions(+), 36 deletions(-) rename Rx/CPP/{testbench/rxcpp.h => src/cpprx/rx-base.hpp} (98%) rename Rx/CPP/{testbench/rxcpp-binder.h => src/cpprx/rx.hpp} (76%) diff --git a/Ix/CPP/.gitignore b/Ix/CPP/.gitignore index 8bbd318..579772e 100644 --- a/Ix/CPP/.gitignore +++ b/Ix/CPP/.gitignore @@ -106,4 +106,9 @@ Generated_Code #added for RIA/Silverlight projects # Visual Studio version. Backup files are not needed, because we have git ;-) _UpgradeReport_Files/ Backup*/ -UpgradeLog*.XML \ No newline at end of file +UpgradeLog*.XML + +# Mac crap +.DS_Store + +a.out diff --git a/Rx/CPP/.gitignore b/Rx/CPP/.gitignore index 5ebd21a..4822a56 100644 --- a/Rx/CPP/.gitignore +++ b/Rx/CPP/.gitignore @@ -161,3 +161,5 @@ pip-log.txt # Mac crap .DS_Store + +a.out diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj index ecef98f..01bf711 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj @@ -46,13 +46,13 @@ true - $(VCInstallDir)include;..\testbench;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\src;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ false - $(VCInstallDir)include;..\testbench;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\src;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h index 8b2f9dd..32ab5ac 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h @@ -60,5 +60,5 @@ #include #include -#include "rxcpp.h" +#include "cpprx/rx.hpp" diff --git a/Rx/CPP/testbench/rxcpp.h b/Rx/CPP/src/cpprx/rx-base.hpp similarity index 98% rename from Rx/CPP/testbench/rxcpp.h rename to Rx/CPP/src/cpprx/rx-base.hpp index 926ae68..3b649a9 100644 --- a/Rx/CPP/testbench/rxcpp.h +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -1,29 +1,9 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if !defined(CPPRX_RX_BASE_HPP) +#define CPPRX_RX_BASE_HPP #pragma once -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max - namespace rxcpp { @@ -883,7 +863,4 @@ namespace rxcpp } } -#include "rxcpp-binder.h" - -#pragma pop_macro("min") -#pragma pop_macro("max") +#endif diff --git a/Rx/CPP/testbench/rxcpp-binder.h b/Rx/CPP/src/cpprx/rx.hpp similarity index 76% rename from Rx/CPP/testbench/rxcpp-binder.h rename to Rx/CPP/src/cpprx/rx.hpp index 0c48e7d..045e4aa 100644 --- a/Rx/CPP/testbench/rxcpp-binder.h +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -1,7 +1,33 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if !defined(CPPRX_RX_HPP) +#define CPPRX_RX_HPP #pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +#include "rx-base.hpp" + namespace rxcpp { template @@ -45,4 +71,9 @@ namespace rxcpp template Binder from(Obj&& obj) { return Binder(std::move(obj)); } -} \ No newline at end of file +} + +#pragma pop_macro("min") +#pragma pop_macro("max") + +#endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index ce99f97..cd6d162 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -3,7 +3,7 @@ // testbench.cpp : Defines the entry point for the console application. // -#include "rxcpp.h" +#include "cpprx/rx.hpp" #include #include diff --git a/Rx/CPP/testbench/testbench.vcxproj b/Rx/CPP/testbench/testbench.vcxproj index 8512615..e357456 100644 --- a/Rx/CPP/testbench/testbench.vcxproj +++ b/Rx/CPP/testbench/testbench.vcxproj @@ -44,11 +44,13 @@ true + $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ false + $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ @@ -85,10 +87,6 @@ - - - - -- GitLab From 06b9f884ea8b9c644f73073572c95da40c73a12d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 09:19:01 -0800 Subject: [PATCH 012/782] get testbench compiling with clang on os.x --- Rx/CPP/src/cpprx/rx-base.hpp | 297 ++++++++++++++++---------------- Rx/CPP/src/cpprx/rx-util.hpp | 18 ++ Rx/CPP/src/cpprx/rx-windows.hpp | 94 ++++++++++ Rx/CPP/src/cpprx/rx.hpp | 48 ++++-- Rx/CPP/testbench/testbench.cpp | 41 +++-- 5 files changed, 325 insertions(+), 173 deletions(-) create mode 100644 Rx/CPP/src/cpprx/rx-util.hpp create mode 100644 Rx/CPP/src/cpprx/rx-windows.hpp diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 3b649a9..29c45ee 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -6,7 +6,6 @@ namespace rxcpp { - ////////////////////////////////////////////////////////////////////// // // Abstract interfaces @@ -218,7 +217,7 @@ namespace rxcpp template Disposable Subscribe( const std::shared_ptr>& source, - typename std::identity>::type onNext, + typename util::identity>::type onNext, std::function onCompleted = nullptr, std::function onError = nullptr ) @@ -228,70 +227,6 @@ namespace rxcpp return source->Subscribe(observer); } - template - struct fix0_thunk { - F f; - fix0_thunk(F&& f) : f(std::move(f)) - { - } - void operator()() const - { - f(*this); - } - }; - template - fix0_thunk fix0(F f) - { - return fix0_thunk(std::move(f)); - } - - template - auto Range( - Integral start, Integral end = (Integral)-1, Integral step = 1 - ) - -> std::shared_ptr> - { - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Integral i; - Integral rem; - }; - auto state = std::make_shared(); - state->cancel = false; - state->i = start; - state->rem = (end - start) / step; - - DefaultScheduler::Instance().Schedule( - fix0([=](std::function self) // TODO: - { - try { - if (state->cancel) - return; - - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - ++state->i; - DefaultScheduler::Instance().Schedule(std::move(self)); - } - } catch (...) { - observer->OnError(std::current_exception()); - } - })); - - return [=]{ state->cancel = true; }; - }); - } - // reference handle type for a container for composing disposables class ComposableDisposable { @@ -427,7 +362,8 @@ namespace rxcpp ) { return CreateObservable( - [=](std::shared_ptr> observer) + [=](std::shared_ptr> observer) + -> Disposable { auto remaining = std::make_shared(n); @@ -499,12 +435,17 @@ namespace rxcpp } ~DefaultScheduler() { - std::unique_lock guard(scheduleLock); - shutdownRequested = true; - guard.unlock(); - cv.notify_one(); + { + std::unique_lock guard(scheduleLock); + shutdownRequested = true; + } + cv.notify_all(); } + + void ScopeEnter() {++trampoline;} + void ScopeExit() {--trampoline; Schedule([]{});} + void Schedule(Work work) { try { @@ -524,9 +465,9 @@ namespace rxcpp { queue.push_back(std::move(work)); } + --trampoline; } - catch (...) - { + catch (...) { --trampoline; throw; } @@ -554,12 +495,14 @@ namespace rxcpp { Clock::time_point dueTime = Clock::now() + std::chrono::duration(milliseconds); - std::unique_lock guard(scheduleLock); - bool wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; + bool wake = false; - scheduledWork.push(std::make_pair(dueTime, std::move(work))); + { + std::unique_lock guard(scheduleLock); + wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; - guard.unlock(); + scheduledWork.push(std::make_pair(dueTime, std::move(work))); + } if (wake) cv.notify_one(); @@ -571,7 +514,6 @@ namespace rxcpp while(!shutdownRequested) { - if (scheduledWork.empty()) { cv.wait(guard); @@ -592,15 +534,83 @@ namespace rxcpp guard.unlock(); try { - work(); + Schedule([=]{work();}); } catch (...) { - // TODO: ??? what now? + // work must catch all expected exceptions + // (yes, expected exceptions is an oxymoron) + std::unexpected(); } guard.lock(); } } }; + template + struct fix0_thunk { + F f; + fix0_thunk(F&& f) : f(std::move(f)) + { + } + void operator()() const + { + f(*this); + } + }; + template + fix0_thunk fix0(F f) + { + return fix0_thunk(std::move(f)); + } + + template + auto Range( + Integral start, Integral end = std::numeric_limits::max(), Integral step = 1 + ) + -> std::shared_ptr> + { + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Integral i; + Integral rem; + }; + auto state = std::make_shared(); + state->cancel = false; + state->i = start; + state->rem = ((end - start) + step) / step; + + DefaultScheduler::Instance().Schedule( + fix0([=](std::function self) // TODO: + { + try { + if (state->cancel) + return; + + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + state->i += step; + DefaultScheduler::Instance().Schedule(std::move(self)); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + })); + + return Disposable([=]{ + state->cancel = true; + }); + }); + } + template std::shared_ptr> Delay( const std::shared_ptr>& source, @@ -616,6 +626,7 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { auto cancel = std::make_shared(false); @@ -667,25 +678,25 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { struct State { - ULONGLONG dueTime; + std::chrono::steady_clock::time_point dueTime; }; auto state = std::make_shared(); - state->dueTime = 0; return Subscribe( source, // on next [=](const T& element) { - auto now = ::GetTickCount64(); + auto now = std::chrono::steady_clock::now(); if (now >= state->dueTime) { observer->OnNext(element); - state->dueTime = now + (ULONGLONG)milliseconds; + state->dueTime = now + std::chrono::duration(milliseconds); } }, // on completed @@ -708,6 +719,7 @@ namespace rxcpp { return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { struct State { T last; bool hasValue; @@ -741,89 +753,86 @@ namespace rxcpp }); } - - - - struct ObserveOnDispatcherOp + class StdQueueDispatcher { - HWND hwnd; + mutable std::queue> pending; + mutable std::condition_variable wake; + mutable std::mutex pendingLock; - ObserveOnDispatcherOp(): hwnd(WindowClass::Instance().CreateWindow_()) + std::function get() const { - if (!hwnd) - throw std::exception("error"); - } - ~ObserveOnDispatcherOp() - { - // send one last message to ourselves to shutdown. - post([=]{ CloseWindow(hwnd); }); + std::function fn; + fn = std::move(pending.front()); + pending.pop(); + return std::move(fn); } - struct WindowClass + void dispatch(std::function fn) const { - static const wchar_t* const className(){ return L"ObserveOnDispatcherOp::WindowClass"; } - WindowClass() + if (fn) { - WNDCLASS wndclass = {}; - wndclass.style = 0; - wndclass.lpfnWndProc = &WndProc; - wndclass.cbClsExtra; - wndclass.cbWndExtra = 0; - wndclass.hInstance = NULL; - wndclass.lpszClassName = className(); - - if (!RegisterClass(&wndclass)) - throw std::exception("error"); - + try { + fn(); + } + catch(...) { + std::unexpected(); + } } - HWND CreateWindow_() + } + + public: + template + void post(Fn fn) const + { { - return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + std::unique_lock guard(pendingLock); + pending.push(std::move(fn)); } - static const int WM_USER_DISPATCH = WM_USER + 1; + wake.notify_one(); + } - static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + void try_dispatch() const + { + std::function fn; { - switch (message) + std::unique_lock guard(pendingLock); + if (!pending.empty()) { - // TODO: shatter attack surface. should validate the message, e.g. using a handle table. - case WM_USER_DISPATCH: - ((void(*)(void*))wParam)((void*)lParam); - return 0; - default: - return DefWindowProc(hwnd, message, wParam, lParam); + fn = get(); } } - static WindowClass& Instance() { - static WindowClass instance; - return instance; - } - }; - - template - void post(Fn fn) const - { - auto p = new Fn(fn); - ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + dispatch(std::move(fn)); } - template - static void run_proc( - void* pvfn - ) + + bool dispatch_one() const { - auto fn = (Fn*)(void*) pvfn; - (*fn)(); - delete fn; + std::function fn; + { + std::unique_lock guard(pendingLock); + wake.wait(guard, [this]{ return !pending.empty();}); + fn = get(); + } + bool result = !!fn; + dispatch(std::move(fn)); + return result; } }; +#if !defined(OBSERVE_ON_DISPATCHER_OP) + typedef StdQueueDispatcher ObserveOnDispatcherOp; +#endif - template + template std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source) + const std::shared_ptr>& source, + std::shared_ptr dispatcher = nullptr) { - auto dispatcher = std::make_shared(); + if (!dispatcher) + { + dispatcher = std::make_shared(); + } return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { auto cancel = std::make_shared(false); @@ -861,6 +870,6 @@ namespace rxcpp return cd; }); } -} +} #endif diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp new file mode 100644 index 0000000..00148fb --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_UTIL_HPP) +#define CPPRX_RX_UTIL_HPP +#pragma once + +namespace rxcpp { namespace util { + + template + struct identity + { + typedef Type type; + Type operator()(const Type& left) const {return left;} + }; + +}} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp new file mode 100644 index 0000000..b20c645 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -0,0 +1,94 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_WINDOWS_HPP) +#define CPPRX_RX_WINDOWS_HPP +#pragma once + +#if defined(WINDOWS) || defined(WIN32) || defined(_WIN32) + +#define NOMINMAX +#include + +namespace rxcpp +{ + +#define OBSERVE_ON_DISPATCHER_OP + + struct ObserveOnDispatcherOp + { + HWND hwnd; + + ObserveOnDispatcherOp(): hwnd(WindowClass::Instance().CreateWindow_()) + { + if (!hwnd) + throw std::exception("error"); + } + ~ObserveOnDispatcherOp() + { + // send one last message to ourselves to shutdown. + post([=]{ CloseWindow(hwnd); }); + } + + struct WindowClass + { + static const wchar_t* const className(){ return L"ObserveOnDispatcherOp::WindowClass"; } + WindowClass() + { + WNDCLASS wndclass = {}; + wndclass.style = 0; + wndclass.lpfnWndProc = &WndProc; + wndclass.cbClsExtra; + wndclass.cbWndExtra = 0; + wndclass.hInstance = NULL; + wndclass.lpszClassName = className(); + + if (!RegisterClass(&wndclass)) + throw std::exception("error"); + + } + HWND CreateWindow_() + { + return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + } + static const int WM_USER_DISPATCH = WM_USER + 1; + + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + { + switch (message) + { + // TODO: shatter attack surface. should validate the message, e.g. using a handle table. + case WM_USER_DISPATCH: + ((void(*)(void*))wParam)((void*)lParam); + return 0; + default: + return DefWindowProc(hwnd, message, wParam, lParam); + } + } + static WindowClass& Instance() { + static WindowClass instance; + return instance; + } + }; + + template + void post(Fn fn) const + { + auto p = new Fn(fn); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + } + template + static void run_proc( + void* pvfn + ) + { + auto fn = (Fn*)(void*) pvfn; + (*fn)(); + delete fn; + } + }; + +} + +#endif + +#endif diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 045e4aa..ce1864e 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -14,22 +14,19 @@ #include #include #include +#include #include #include #include #include -#include - -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max +#include "rx-util.hpp" +#include "rx-windows.hpp" #include "rx-base.hpp" namespace rxcpp -{ +{ template class Binder { @@ -59,21 +56,44 @@ namespace rxcpp auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } - auto on_dispatcher() -> decltype(from(ObserveOnDispatcher(obj))) + template + auto observe_on(std::shared_ptr dispatcher) + -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) + { + return from(ObserveOnDispatcher(obj, std::move(dispatcher))); + } + auto on_dispatcher(std::shared_ptr dispatcher = nullptr) + -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) { - return from(ObserveOnDispatcher(obj)); + return from(ObserveOnDispatcher(obj, std::move(dispatcher))); } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - return Subscribe(obj, onNext); + DefaultScheduler::Instance().ScopeEnter(); + auto result = Subscribe(obj, onNext); + DefaultScheduler::Instance().ScopeExit(); + return result; + } + template + auto subscribe(OnNext onNext, OnComplete onComplete) -> decltype(Subscribe(obj, onNext, onComplete)) { + DefaultScheduler::Instance().ScopeEnter(); + auto result = Subscribe(obj, onNext, onComplete); + DefaultScheduler::Instance().ScopeExit(); + return result; + } + template + auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) + -> decltype(Subscribe(obj, onNext, onComplete, onError)) { + DefaultScheduler::Instance().ScopeEnter(); + auto result = Subscribe(obj, onNext, onComplete, onError); + DefaultScheduler::Instance().ScopeExit(); + return result; } }; template - Binder from(Obj&& obj) { return Binder(std::move(obj)); } + Binder::type> from(Obj&& obj) { + return Binder::type>(std::move(obj)); } } -#pragma pop_macro("min") -#pragma pop_macro("max") - #endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index cd6d162..1aeb807 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -6,30 +6,41 @@ #include "cpprx/rx.hpp" #include +#include #include +#include +#include +#include using namespace std; bool IsPrime(int x); -int main(int argc, char* argv[]) +void PrintPrimes(int n) { - const int n = 20; - std::cout << "first " << n << " primes squared\n"; - - rxcpp::DefaultScheduler::Instance().Schedule( - [=] - { - auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values) - .where(IsPrime) - .select([](int x) { return std::make_pair(x, x*x); }) - .take(n) - .subscribe( + bool done = false; + auto dispatcher = std::make_shared(); + auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values) + .where(IsPrime) + .select([](int x) { return std::make_pair(x, x*x); }) + .take(n) + .on_dispatcher(dispatcher) + .subscribe( [](pair p) { cout << p.first << " =square=> " << p.second << endl; - }); - }); + }, + [&done](){done = true;}, + [&done](const std::exception_ptr&){done = true;}); + + std::cout << "first " << n << " primes squared" << endl; + while(!done){dispatcher->dispatch_one();} +} + + +int main(int argc, char* argv[]) +{ + PrintPrimes(20); } bool IsPrime(int x) -- GitLab From 2bd57bcfc3dac65c2ef335d3968288963ed0b07e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 18:52:20 -0800 Subject: [PATCH 013/782] fix windows bugs --- Rx/CPP/src/cpprx/rx-base.hpp | 15 ++++++--------- Rx/CPP/src/cpprx/rx.hpp | 24 +++++++++++++----------- Rx/CPP/testbench/testbench.cpp | 11 ++--------- 3 files changed, 21 insertions(+), 29 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 29c45ee..f677c71 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -818,19 +818,16 @@ namespace rxcpp } }; #if !defined(OBSERVE_ON_DISPATCHER_OP) - typedef StdQueueDispatcher ObserveOnDispatcherOp; + typedef StdQueueDispatcher c; #endif - template + template std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source, - std::shared_ptr dispatcher = nullptr) + const std::shared_ptr>& source) { - if (!dispatcher) - { - dispatcher = std::make_shared(); - } - return CreateObservable( + auto dispatcher = std::make_shared(); + + return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index ce1864e..6d8ffd9 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -4,6 +4,11 @@ #define CPPRX_RX_HPP #pragma once +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + #include #include #include @@ -32,7 +37,7 @@ namespace rxcpp { Obj obj; public: - Binder(Obj&& obj) : obj(std::move(obj)) + Binder(Obj obj) : obj(std::move(obj)) { } template @@ -56,16 +61,10 @@ namespace rxcpp auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } - template - auto observe_on(std::shared_ptr dispatcher) - -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) - { - return from(ObserveOnDispatcher(obj, std::move(dispatcher))); - } - auto on_dispatcher(std::shared_ptr dispatcher = nullptr) - -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) + auto on_dispatcher() + -> decltype(from(ObserveOnDispatcher(obj))) { - return from(ObserveOnDispatcher(obj, std::move(dispatcher))); + return from(ObserveOnDispatcher(obj)); } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { @@ -92,8 +91,11 @@ namespace rxcpp }; template Binder::type> from(Obj&& obj) { - return Binder::type>(std::move(obj)); } + return Binder::type>(std::forward(obj)); } } +#pragma pop_macro("min") +#pragma pop_macro("max") + #endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 1aeb807..23a4000 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -18,23 +18,16 @@ bool IsPrime(int x); void PrintPrimes(int n) { - bool done = false; - auto dispatcher = std::make_shared(); + std::cout << "first " << n << " primes squared" << endl; auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers auto s1 = rxcpp::from(values) .where(IsPrime) .select([](int x) { return std::make_pair(x, x*x); }) .take(n) - .on_dispatcher(dispatcher) .subscribe( [](pair p) { cout << p.first << " =square=> " << p.second << endl; - }, - [&done](){done = true;}, - [&done](const std::exception_ptr&){done = true;}); - - std::cout << "first " << n << " primes squared" << endl; - while(!done){dispatcher->dispatch_one();} + }); } -- GitLab From 62b675aae67ac373171f4412daa9d3349449ae9a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 20:55:11 -0800 Subject: [PATCH 014/782] add thread local and unwinder --- Rx/CPP/src/cpprx/rx-util.hpp | 57 ++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 00148fb..d1f69c7 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -4,6 +4,19 @@ #define CPPRX_RX_UTIL_HPP #pragma once +#if !defined(RXCPP_THREAD_LOCAL) +#if defined(_MSC_VER) +#define RXCPP_THREAD_LOCAL __declspec(thread) +#else +#define RXCPP_THREAD_LOCAL __thread +#endif +#endif + +#define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix +#define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) + +#define RXCPP_MAKE_IDENTIFIER(Prefix) RXCPP_CONCAT_EVALUATE(Prefix, __LINE__) + namespace rxcpp { namespace util { template @@ -13,6 +26,50 @@ namespace rxcpp { namespace util { Type operator()(const Type& left) const {return left;} }; + template + class unwinder + { + public: + ~unwinder() + { + if (!!function) + { + try { + (*function)(); + } catch (...) { + std::unexpected(); + } + } + } + + explicit unwinder(Function* functionArg) + : function(functionArg) + { + } + + void dismiss() + { + function = nullptr; + } + + private: + unwinder(); + unwinder(const unwinder&); + unwinder& operator=(const unwinder&); + + Function* function; + }; + }} +#define RXCPP_UNWIND(Name, Function) \ + RXCPP_UNWIND_EXPLICIT(uwfunc_ ## Name, Name, Function) + +#define RXCPP_UNWIND_AUTO(Function) \ + RXCPP_UNWIND_EXPLICIT(RXCPP_MAKE_IDENTIFIER(uwfunc_), RXCPP_MAKE_IDENTIFIER(unwind_), Function) + +#define RXCPP_UNWIND_EXPLICIT(FunctionName, UnwinderName, Function) \ + auto FunctionName = (Function); \ + rxcpp::util::unwinder UnwinderName(std::addressof(FunctionName)) + #endif \ No newline at end of file -- GitLab From 9cf8501513d922a2ced4dbe355712103a7cd9aa4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 21:13:29 -0800 Subject: [PATCH 015/782] changes to Disposable --- Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 2 +- Rx/CPP/src/cpprx/rx-base.hpp | 30 +++++++++++++++++----- 2 files changed, 24 insertions(+), 8 deletions(-) diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp index ed928a0..f86d500 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -76,7 +76,7 @@ void CMainFrame::UserInit() this->UpdateWindow(); }); - composableDisposable.Add(s); + composableDisposable.Add(std::move(s)); } } diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index f677c71..3349a91 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -22,16 +22,32 @@ namespace rxcpp class Disposable { - std::function dispose; + Disposable(); + Disposable(const Disposable&); + typedef std::function dispose_type; + dispose_type dispose; public: - Disposable(std::function dispose) : dispose(std::move(dispose)) - { + explicit Disposable(dispose_type disposearg) + : dispose(std::move(disposearg)) { + disposearg = nullptr;} + Disposable(Disposable&& other) + : dispose(std::move(other.dispose)) { + other.dispose = nullptr; } + Disposable& operator=(Disposable other) { + swap(other); + return *this; } void Dispose() { - if (dispose) dispose(); + if (dispose) { + dispose(); + dispose = nullptr; + } } + void swap(Disposable& rhs) {{using std::swap; swap(dispose, rhs.dispose);}} + static Disposable Empty() { return Disposable(nullptr); } }; + void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} template struct Observable @@ -176,12 +192,12 @@ namespace rxcpp std::weak_ptr> wptr = observer; std::weak_ptr wself = this->shared_from_this(); - Disposable d = [wptr, wself]{ + Disposable d([wptr, wself]{ if (auto self = wself.lock()) { self->RemoveObserver(wptr.lock()); } - }; + }); for(auto& o : observers) { @@ -827,7 +843,7 @@ namespace rxcpp { auto dispatcher = std::make_shared(); - return CreateObservable( + return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { -- GitLab From d5bc1514115a070212b01b9ed966ca98aa52810c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 21:18:34 -0800 Subject: [PATCH 016/782] add Scheduler and more disposables --- Rx/CPP/src/cpprx/rx-base.hpp | 248 ++++++++++++++++++++++++++--------- 1 file changed, 189 insertions(+), 59 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 3349a91..15584ae 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -56,6 +56,195 @@ namespace rxcpp virtual ~Observable() {} }; + struct Scheduler : public std::enable_shared_from_this + { + typedef std::chrono::steady_clock clock; + typedef std::shared_ptr shared; + typedef std::function Work; + + shared get() {return shared_from_this();} + + virtual ~Scheduler() {} + + virtual clock::time_point Now() =0; + virtual Disposable Schedule(Work work) = 0; + virtual Disposable Schedule(clock::duration due, Work work) = 0; + virtual Disposable Schedule(clock::time_point due, Work work) = 0; + }; + + ////////////////////////////////////////////////////////////////////// + // + // disposables + + + // reference handle type for a container for composing disposables + class ComposableDisposable + { + struct State + { + std::vector disposables; + std::mutex lock; + bool isDisposed; + + State() : isDisposed(false) + { + } + void Add(Disposable&& d) + { + std::unique_lock guard(lock); + if (isDisposed) { + guard.unlock(); + d.Dispose(); + } else { + disposables.emplace_back(std::move(d)); + } + } + void Dispose() + { + std::unique_lock guard(lock); + + if (!isDisposed) + { + isDisposed = true; + auto v = std::move(disposables); + guard.unlock(); + + std::for_each(v.begin(), v.end(), + [](Disposable& d) { + d.Dispose(); }); + } + } + }; + + std::shared_ptr state; + + public: + + ComposableDisposable() : state(new State) + { + } + void Add(Disposable d) const + { + state->Add(std::move(d)); + } + void Dispose() const + { + state->Dispose(); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; + + class ScheduledDisposable + { + struct State : public std::enable_shared_from_this + { + Scheduler::shared scheduler; + Disposable disposable; + + State(Scheduler::shared scheduler, Disposable disposable) + : scheduler(std::move(scheduler)) + , disposable(std::move(disposable)) + { + } + void Dispose() + { + auto local = std::move(scheduler); + if (local) { + auto keepAlive = shared_from_this(); + local->Schedule([keepAlive] (Scheduler::shared) { + keepAlive->disposable.Dispose(); + return Disposable::Empty(); + }); + } + } + }; + + std::shared_ptr state; + + ScheduledDisposable(); + public: + + ScheduledDisposable(Scheduler::shared scheduler, Disposable disposable) + : state(new State(std::move(scheduler), std::move(disposable))) + { + } + void Dispose() const + { + state->Dispose(); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; + + class SharedDisposable + { + typedef std::function dispose_type; + + struct State : public std::enable_shared_from_this + { + mutable Disposable disposable; + mutable std::mutex lock; + + State() : disposable(Disposable::Empty()) {} + + void Set(Disposable disposeArg) const + { + std::unique_lock guard(lock); + {using std::swap; swap(disposable, disposeArg);} + } + void Dispose() + { + std::unique_lock guard(lock); + auto local = std::move(disposable); + guard.unlock(); + local.Dispose(); + } + }; + + std::shared_ptr state; + + public: + + SharedDisposable() + : state(new State()) + { + } + void Dispose() const + { + state->Dispose(); + } + void Set(Disposable disposeArg) const + { + state->Set(std::move(disposeArg)); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; ////////////////////////////////////////////////////////////////////// @@ -243,65 +432,6 @@ namespace rxcpp return source->Subscribe(observer); } - // reference handle type for a container for composing disposables - class ComposableDisposable - { - struct State - { - std::vector disposables; - std::mutex lock; - bool isDisposed; - - State() : isDisposed(false) - { - } - void Add(Disposable&& d) - { - std::unique_lock guard(lock); - if (isDisposed) { - guard.unlock(); - d.Dispose(); - } else { - disposables.push_back(std::move(d)); - } - } - void Dispose() - { - std::unique_lock guard(lock); - - isDisposed = true; - auto v = std::move(disposables); - guard.unlock(); - - std::for_each(v.begin(), v.end(), - [](Disposable& d) { d.Dispose(); }); - } - }; - - std::shared_ptr state; - - public: - ComposableDisposable() : state(new State) - { - } - void Add(Disposable d) const - { - state->Add(std::move(d)); - } - void Dispose() const - { - state->Dispose(); - } - operator Disposable() const - { - auto d = Disposable([=]{ - state->Dispose(); - }); - return d; - } - }; - - ////////////////////////////////////////////////////////////////////// // -- GitLab From 7eda5b02daff5e70198def84e2df530426781b14 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 1 Mar 2013 10:51:44 -0800 Subject: [PATCH 017/782] add scheduler impl and usage added basic schedulers (Immediate, CurrentThread, EventLoop, NewThread) added subscribe_on and observe_on used these in the test and sample code added WindowScheduler --- Ix/CPP/src/cpplinq/util.hpp | 8 + Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 6 +- Rx/CPP/src/cpprx/rx-base.hpp | 770 +-------------------- Rx/CPP/src/cpprx/rx-operators.hpp | 752 ++++++++++++++++++++ Rx/CPP/src/cpprx/rx-scheduler.h | 395 +++++++++++ Rx/CPP/src/cpprx/rx-util.hpp | 110 ++- Rx/CPP/src/cpprx/rx-windows.hpp | 95 ++- Rx/CPP/src/cpprx/rx.hpp | 27 +- Rx/CPP/testbench/data.txt | 655 ++++++++++++++++++ Rx/CPP/testbench/testbench.cpp | 200 ++++++ Rx/CPP/testbench/testbench.vcxproj | 4 +- Rx/CPP/testbench/testbench.vcxproj.filters | 8 - 12 files changed, 2255 insertions(+), 775 deletions(-) create mode 100644 Rx/CPP/src/cpprx/rx-operators.hpp create mode 100644 Rx/CPP/src/cpprx/rx-scheduler.h create mode 100644 Rx/CPP/testbench/data.txt diff --git a/Ix/CPP/src/cpplinq/util.hpp b/Ix/CPP/src/cpplinq/util.hpp index f1e5222..953a48a 100644 --- a/Ix/CPP/src/cpplinq/util.hpp +++ b/Ix/CPP/src/cpplinq/util.hpp @@ -200,6 +200,14 @@ namespace cpplinq { namespace util { is_set = true; } } + void set(T&& value) { + if (is_set) { + *reinterpret_cast(&storage) = std::move(value); + } else { + new (reinterpret_cast(&storage)) T(std::move(value)); + is_set = true; + } + } T& operator*() { return *get(); } const T& operator*() const { return *get(); } diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp index f86d500..da3d39a 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -48,6 +48,8 @@ CMainFrame::~CMainFrame() // inspired by: http://minirx.codeplex.com/ void CMainFrame::UserInit() { + auto worker = std::make_shared(); + auto mainFormScheduler = std::make_shared(); auto mouseMove = BindEventToObservable(mouseMoveEvent); // set up labels and query @@ -64,8 +66,8 @@ void CMainFrame::UserInit() auto s = rxcpp::from(mouseMove) .select([](MouseMoveEventValue e) { return e.point; }) .distinct_until_changed() - .delay(i * 100 + 1) - .on_dispatcher() + .delay(std::chrono::milliseconds(i * 100 + 1), worker) + .observe_on(mainFormScheduler) .subscribe([=](CPoint point) { label->SetWindowPos(nullptr, point.x+20*i, point.y-20, 20, 30, SWP_NOOWNERZORDER); diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 15584ae..cf6642b 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -47,7 +47,7 @@ namespace rxcpp void swap(Disposable& rhs) {{using std::swap; swap(dispose, rhs.dispose);}} static Disposable Empty() { return Disposable(nullptr); } }; - void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} + inline void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} template struct Observable @@ -246,773 +246,55 @@ namespace rxcpp } }; - - ////////////////////////////////////////////////////////////////////// - // - // constructors - - template - class CreatedObservable : public Observable - { - S subscribe; - - public: - CreatedObservable(S subscribe) : subscribe(std::move(subscribe)) - { - } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - return subscribe(std::move(observer)); - } - }; - - template - std::shared_ptr> CreateObservable(S subscribe) - { - return std::make_shared>(std::move(subscribe)); - } - - template - struct CreatedObserver : public Observer - { - std::function onNext; - std::function onCompleted; - std::function onError; - - virtual void OnNext(const T& element) - { - try - { - if(onNext) - { - onNext(element); - } - } - catch (...) - { - OnError(std::current_exception()); - } - } - virtual void OnCompleted() - { - if(onCompleted) - { - onCompleted(); - clear(); - } - } - virtual void OnError(const std::exception_ptr& error) - { - if(onError) - { - onError(error); - clear(); - } - } - void clear() - { - onNext = nullptr; - onCompleted = nullptr; - onError = nullptr; - } - }; - - template - std::shared_ptr> CreateObserver( - std::function onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) + struct LocalScheduler : public Scheduler { - auto p = std::make_shared>(); - p->onNext = std::move(onNext); - p->onCompleted = std::move(onCompleted); - p->onError = std::move(onError); - - return p; - } - - template - class Subject : - public Observable, - public Observer, - public std::enable_shared_from_this> - { - std::vector>> observers; - public: - virtual void OnNext(const T& element) - { - for(auto& o : observers) - { - try - { - if (o) - o->OnNext(element); - } - catch (...) - { - auto o_ = std::move(o); - o_->OnError(std::current_exception()); - } - } - } - virtual void OnCompleted() - { - for(auto& o : observers) - { - if (o) { - o->OnCompleted(); - o = nullptr; - } - } - } - virtual void OnError(const std::exception_ptr& error) - { - for(auto& o : observers) - { - if (o) { - o->OnError(error); - o = nullptr; - } - } - } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - for(auto& o : observers) - { - if (!o){ - o = std::move(observer); - return d; - } - } - observers.push_back(std::move(observer)); - return d; - } - private: - void RemoveObserver(std::shared_ptr> toRemove) - { - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - *it = nullptr; - } - }; - - template - std::shared_ptr> CreateSubject() - { - return std::make_shared>(); - } - - - ////////////////////////////////////////////////////////////////////// - // - // imperative functions - - template - Disposable Subscribe( - const std::shared_ptr>& source, - typename util::identity>::type onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) - { - auto observer = CreateObserver(std::move(onNext), std::move(onCompleted), std::move(onError)); - - return source->Subscribe(observer); - } - + LocalScheduler(const LocalScheduler&); - ////////////////////////////////////////////////////////////////////// - // - // standard query operators - - template - auto Select( - const std::shared_ptr>& source, - S selector - ) - -> const std::shared_ptr::type>> - { - typedef typename std::result_of::type U; - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - auto result = selector(element); - observer->OnNext(std::move(result)); - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - template - const std::shared_ptr> Where( - const std::shared_ptr>& source, - P predicate - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - auto result = predicate(element); - if (result) - { - observer->OnNext(element); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - template - std::shared_ptr> Take( - const std::shared_ptr>& source, - int n // TODO: long long? - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto remaining = std::make_shared(n); - - ComposableDisposable cd; - - auto d = Subscribe( - source, - // on next - [=](const T& element) - { - if (*remaining) - { - observer->OnNext(element); - if (--*remaining == 0) - { - observer->OnCompleted(); - cd.Dispose(); - } - } - }, - // on completed - [=] - { - if (*remaining) - { - observer->OnCompleted(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - if (*remaining) - { - observer->OnError(error); - } - }); - cd.Add(std::move(d)); - return cd; - }); - } - - - - ////////////////////////////////////////////////////////////////////// - // - // time and schedulers - - struct DefaultScheduler - { - private: DefaultScheduler(const DefaultScheduler&); public: - static DefaultScheduler& Instance() - { - // TODO: leaks. race condition on atexit though. - static DefaultScheduler* instance = new DefaultScheduler; - return *instance; - } - - typedef std::function Work; - - std::atomic trampoline; - - std::vector queue; - - std::thread worker_thread; - DefaultScheduler() : trampoline(0), shutdownRequested(false) - { - worker_thread = std::thread([=]{ worker(); }); - } - ~DefaultScheduler() + static void DoNoThrow(Work& work, Scheduler::shared scheduler) throw() { + if (work) { - std::unique_lock guard(scheduleLock); - shutdownRequested = true; + work(std::move(scheduler)); } - cv.notify_all(); } - - - void ScopeEnter() {++trampoline;} - void ScopeExit() {--trampoline; Schedule([]{});} - - void Schedule(Work work) + static void Do(Work& work, Scheduler::shared scheduler) { try { - if (++trampoline == 1) - { - work(); - - while(!queue.empty()) - { - work = std::move(queue.back()); - queue.pop_back(); - work(); - } - - } - else - { - queue.push_back(std::move(work)); - } - --trampoline; - } - catch (...) { - --trampoline; - throw; - } - } - - struct compare_work - { - template - bool operator()(const T& work1, const T& work2) const { - return work1.first > work2.first; - } - }; - - typedef std::chrono::steady_clock Clock; - - bool shutdownRequested; - std::mutex scheduleLock; - std::condition_variable cv; - std::priority_queue< std::pair, - std::vector>, - compare_work > scheduledWork; - - - void Schedule(int milliseconds, Work work) - { - Clock::time_point dueTime = Clock::now() + std::chrono::duration(milliseconds); - - bool wake = false; - - { - std::unique_lock guard(scheduleLock); - wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; - - scheduledWork.push(std::make_pair(dueTime, std::move(work))); - } - - if (wake) - cv.notify_one(); - } - private: - void worker() - { - std::unique_lock guard(scheduleLock); - - while(!shutdownRequested) - { - if (scheduledWork.empty()) - { - cv.wait(guard); - continue; - } - - auto now = Clock::now(); - auto dueTime = scheduledWork.top().first; - if (dueTime > now) - { - cv.wait_until(guard, dueTime); - continue; - } - - // dispatch work - auto work = std::move(scheduledWork.top().second); - scheduledWork.pop(); - - guard.unlock(); - try { - Schedule([=]{work();}); - } catch (...) { - // work must catch all expected exceptions - // (yes, expected exceptions is an oxymoron) - std::unexpected(); - } - guard.lock(); + DoNoThrow(work, std::move(scheduler)); + } catch (const std::exception& ) { + // work must catch all expected exceptions + std::unexpected(); + } catch (...) { + // work must catch all expected exceptions + std::unexpected(); } } - }; - - template - struct fix0_thunk { - F f; - fix0_thunk(F&& f) : f(std::move(f)) - { - } - void operator()() const - { - f(*this); - } - }; - template - fix0_thunk fix0(F f) - { - return fix0_thunk(std::move(f)); - } - - template - auto Range( - Integral start, Integral end = std::numeric_limits::max(), Integral step = 1 - ) - -> std::shared_ptr> - { - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Integral i; - Integral rem; - }; - auto state = std::make_shared(); - state->cancel = false; - state->i = start; - state->rem = ((end - start) + step) / step; - - DefaultScheduler::Instance().Schedule( - fix0([=](std::function self) // TODO: - { - try { - if (state->cancel) - return; - - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - state->i += step; - DefaultScheduler::Instance().Schedule(std::move(self)); - } - } catch (...) { - observer->OnError(std::current_exception()); - } - })); - return Disposable([=]{ - state->cancel = true; - }); - }); - } - - template - std::shared_ptr> Delay( - const std::shared_ptr>& source, - int milliseconds) - { - // TODO: for some reason, poor interactions take place if - // on_dispatcher() dispatches from UI thread. -#if 0 - if (milliseconds == 0) - return source; -#endif - - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ *cancel = true; })); - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - // TODO: queue - DefaultScheduler::Instance().Schedule( - milliseconds, - [=]{ - if (!*cancel) - observer->OnNext(element); - }); - }, - // on completed - [=] - { - DefaultScheduler::Instance().Schedule( - milliseconds, - [=]{ - if (!*cancel) - observer->OnCompleted(); - }); - }, - // on error - [=](const std::exception_ptr& error) - { - if (!*cancel) - observer->OnError(error); - })); - return cd; - }); - } - - // no more than one event ever 'milliseconds' - // TODO: oops, this is not the right definition for throttle. - template - std::shared_ptr> LimitWindow( - const std::shared_ptr>& source, - int milliseconds) - { - if (milliseconds == 0) - return source; - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - std::chrono::steady_clock::time_point dueTime; - }; - - auto state = std::make_shared(); - - return Subscribe( - source, - // on next - [=](const T& element) - { - auto now = std::chrono::steady_clock::now(); - - if (now >= state->dueTime) - { - observer->OnNext(element); - state->dueTime = now + std::chrono::duration(milliseconds); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 - template - std::shared_ptr> DistinctUntilChanged( - const std::shared_ptr>& source) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - T last; bool hasValue; - }; - - auto state = std::make_shared(); - state->hasValue = false; - - return Subscribe( - source, - // on next - [=](const T& element) - { - if (!state->hasValue || state->last != element) - { - observer->OnNext(element); - state->last = element; - state->hasValue = true; - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - class StdQueueDispatcher - { - mutable std::queue> pending; - mutable std::condition_variable wake; - mutable std::mutex pendingLock; - - std::function get() const + public: + LocalScheduler() { - std::function fn; - fn = std::move(pending.front()); - pending.pop(); - return std::move(fn); } - - void dispatch(std::function fn) const + virtual ~LocalScheduler() { - if (fn) - { - try { - fn(); - } - catch(...) { - std::unexpected(); - } - } } - public: - template - void post(Fn fn) const - { - { - std::unique_lock guard(pendingLock); - pending.push(std::move(fn)); - } - wake.notify_one(); - } + virtual clock::time_point Now() {return clock::now();} - void try_dispatch() const + using Scheduler::Schedule; + virtual Disposable Schedule(Work work) { - std::function fn; - { - std::unique_lock guard(pendingLock); - if (!pending.empty()) - { - fn = get(); - } - } - dispatch(std::move(fn)); + clock::time_point dueTime = clock::now(); + return Schedule(dueTime, std::move(work)); } - - bool dispatch_one() const + + virtual Disposable Schedule(clock::duration due, Work work) { - std::function fn; - { - std::unique_lock guard(pendingLock); - wake.wait(guard, [this]{ return !pending.empty();}); - fn = get(); - } - bool result = !!fn; - dispatch(std::move(fn)); - return result; + clock::time_point dueTime = clock::now() + due; + return Schedule(dueTime, std::move(work)); } }; -#if !defined(OBSERVE_ON_DISPATCHER_OP) - typedef StdQueueDispatcher c; -#endif - - template - std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source) - { - auto dispatcher = std::make_shared(); - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - *cancel = true; - })); - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - dispatcher->post([=]{ - if (!*cancel) - observer->OnNext(element); - }); - }, - // on completed - [=] - { - dispatcher->post([=]{ - if(!*cancel) - observer->OnCompleted(); - }); - }, - // on error - [=](const std::exception_ptr& error) - { - dispatcher->post([=]{ - if (!*cancel) - observer->OnError(error); - }); - })); - return cd; - }); - } } #endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp new file mode 100644 index 0000000..e4250b1 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -0,0 +1,752 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_OPERATORS_HPP) +#define CPPRX_RX_OPERATORS_HPP +#pragma once + +namespace rxcpp +{ + + ////////////////////////////////////////////////////////////////////// + // + // constructors + + template + class CreatedObservable : public Observable + { + S subscribe; + + public: + CreatedObservable(S subscribe) + : subscribe(std::move(subscribe)) + { + } + virtual Disposable Subscribe(std::shared_ptr> observer) + { + if (CurrentThreadScheduler::IsScheduleRequired()) { + auto scheduler = std::make_shared(); + return scheduler->Schedule( + [=](Scheduler::shared){ + try { + return subscribe(observer); + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + } + ); + } + try { + return subscribe(observer); + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + } + }; + + template + std::shared_ptr> CreateObservable(S subscribe) + { + return std::make_shared>(std::move(subscribe)); + } + + template + struct CreatedObserver : public Observer + { + std::function onNext; + std::function onCompleted; + std::function onError; + + virtual void OnNext(const T& element) + { + try + { + if(onNext) + { + onNext(element); + } + } + catch (...) + { + OnError(std::current_exception()); + } + } + virtual void OnCompleted() + { + if(onCompleted) + { + onCompleted(); + clear(); + } + } + virtual void OnError(const std::exception_ptr& error) + { + if(onError) + { + onError(error); + clear(); + } + } + void clear() + { + onNext = nullptr; + onCompleted = nullptr; + onError = nullptr; + } + }; + + template + std::shared_ptr> CreateObserver( + std::function onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto p = std::make_shared>(); + p->onNext = std::move(onNext); + p->onCompleted = std::move(onCompleted); + p->onError = std::move(onError); + + return p; + } + + template + class Subject : + public Observable, + public Observer, + public std::enable_shared_from_this> + { + std::vector>> observers; + public: + virtual void OnNext(const T& element) + { + for(auto& o : observers) + { + try + { + if (o) + o->OnNext(element); + } + catch (...) + { + auto o_ = std::move(o); + o_->OnError(std::current_exception()); + } + } + } + virtual void OnCompleted() + { + for(auto& o : observers) + { + if (o) { + o->OnCompleted(); + o = nullptr; + } + } + } + virtual void OnError(const std::exception_ptr& error) + { + for(auto& o : observers) + { + if (o) { + o->OnError(error); + o = nullptr; + } + } + } + virtual Disposable Subscribe(std::shared_ptr> observer) + { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d([wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }); + + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(std::move(observer)); + return d; + } + + private: + void RemoveObserver(std::shared_ptr> toRemove) + { + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } + }; + + template + std::shared_ptr> CreateSubject() + { + return std::make_shared>(); + } + + template + struct fix0_thunk { + F f; + fix0_thunk(F&& f) : f(std::move(f)) + { + } + Disposable operator()(Scheduler::shared s) const + { + return f(s, *this); + } + }; + template + fix0_thunk fix0(F f) + { + return fix0_thunk(std::move(f)); + } + + template + auto Range( + Integral start, Integral end = std::numeric_limits::max(), Integral step = 1, + Scheduler::shared scheduler = nullptr) + -> std::shared_ptr> + { + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Integral i; + Integral rem; + }; + auto state = std::make_shared(); + state->cancel = false; + state->i = start; + state->rem = ((end - start) + step) / step; + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + try { + if (state->cancel) + return Disposable::Empty(); + + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + state->i += step; + return s->Schedule(std::move(self)); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + }))); + + return cd; + }); + } + + + ////////////////////////////////////////////////////////////////////// + // + // imperative functions + + template + Disposable Subscribe( + const std::shared_ptr>& source, + typename util::identity>::type onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto observer = CreateObserver(std::move(onNext), std::move(onCompleted), std::move(onError)); + + return source->Subscribe(observer); + } + + + ////////////////////////////////////////////////////////////////////// + // + // standard query operators + + template + auto Select( + const std::shared_ptr>& source, + S selector + ) + -> const std::shared_ptr::type>> + { + typedef typename std::result_of::type U; + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + auto result = selector(element); + observer->OnNext(std::move(result)); + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + const std::shared_ptr> Where( + const std::shared_ptr>& source, + P predicate + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + auto result = predicate(element); + if (result) + { + observer->OnNext(element); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + std::shared_ptr> Take( + const std::shared_ptr>& source, + int n // TODO: long long? + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto remaining = std::make_shared(n); + + ComposableDisposable cd; + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (*remaining) + { + observer->OnNext(element); + if (--*remaining == 0) + { + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on completed + [=] + { + if (*remaining) + { + observer->OnCompleted(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + if (*remaining) + { + observer->OnError(error); + } + })); + return cd; + }); + } + + + ////////////////////////////////////////////////////////////////////// + // + // time + + template + std::shared_ptr> Delay( + const std::shared_ptr>& source, + Scheduler::clock::duration due, + Scheduler::shared scheduler = nullptr) + { + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ *cancel = true; })); + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + sd.Set(scheduler->Schedule( + due, + [=] (Scheduler::shared){ + if (!*cancel) + observer->OnNext(element); + return Disposable::Empty(); + } + )); + }, + // on completed + [=] + { + sd.Set(scheduler->Schedule( + due, + [=](Scheduler::shared){ + if (!*cancel) + observer->OnCompleted(); + return Disposable::Empty(); + } + )); + }, + // on error + [=](const std::exception_ptr& error) + { + if (!*cancel) + observer->OnError(error); + })); + return cd; + }); + } + + // no more than one event ever 'milliseconds' + // TODO: oops, this is not the right definition for throttle. + template + std::shared_ptr> LimitWindow( + const std::shared_ptr>& source, + int milliseconds) + { + if (milliseconds == 0) + return source; + + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + std::chrono::steady_clock::time_point dueTime; + }; + + auto state = std::make_shared(); + + return Subscribe( + source, + // on next + [=](const T& element) + { + auto now = std::chrono::steady_clock::now(); + + if (now >= state->dueTime) + { + observer->OnNext(element); + state->dueTime = now + std::chrono::duration(milliseconds); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 + template + std::shared_ptr> DistinctUntilChanged( + const std::shared_ptr>& source) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + T last; bool hasValue; + }; + + auto state = std::make_shared(); + state->hasValue = false; + + return Subscribe( + source, + // on next + [=](const T& element) + { + if (!state->hasValue || state->last != element) + { + observer->OnNext(element); + state->last = element; + state->hasValue = true; + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + std::shared_ptr> SubscribeOnObservable( + const std::shared_ptr>& source, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + ComposableDisposable cd; + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(scheduler->Schedule([=](Scheduler::shared){ + sd.Set(ScheduledDisposable(scheduler, source->Subscribe(observer))); + return Disposable::Empty(); + })); + return cd; + }); + } + + template + std::shared_ptr> ObserveOnObserver( + const std::shared_ptr>& source, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto queue = std::make_shared(); + auto queueScheduler = queue->GetScheduler(); + + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + queue->Dispose(); + })); + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + sd.Set(queueScheduler->Schedule([=](Scheduler::shared){ + observer->OnNext(element); + return Disposable::Empty(); + })); + queue->RunOnScheduler(scheduler); + }, + // on completed + [=] + { + sd.Set(queueScheduler->Schedule( + [=](Scheduler::shared){ + observer->OnCompleted(); + return Disposable::Empty(); + } + )); + queue->RunOnScheduler(scheduler); + }, + // on error + [=](const std::exception_ptr& error) + { + queueScheduler->Schedule([=](Scheduler::shared){ + observer->OnError(error); + queue->Dispose(); + return Disposable::Empty(); + }); + queue->RunOnScheduler(scheduler); + })); + return cd; + }); + } + + class StdQueueDispatcher + { + mutable std::queue> pending; + mutable std::condition_variable wake; + mutable std::mutex pendingLock; + + std::function get() const + { + std::function fn; + fn = std::move(pending.front()); + pending.pop(); + return std::move(fn); + } + + void dispatch(std::function fn) const + { + if (fn) + { + try { + fn(); + } + catch(...) { + std::unexpected(); + } + } + } + + public: + template + void post(Fn fn) const + { + { + std::unique_lock guard(pendingLock); + pending.push(std::move(fn)); + } + wake.notify_one(); + } + + void try_dispatch() const + { + std::function fn; + { + std::unique_lock guard(pendingLock); + if (!pending.empty()) + { + fn = get(); + } + } + dispatch(std::move(fn)); + } + + bool dispatch_one() const + { + std::function fn; + { + std::unique_lock guard(pendingLock); + wake.wait(guard, [this]{ return !pending.empty();}); + fn = get(); + } + bool result = !!fn; + dispatch(std::move(fn)); + return result; + } + }; +#if defined(OBSERVE_ON_DISPATCHER_OP) + typedef OBSERVE_ON_DISPATCHER_OP ObserveOnDispatcherOp; +#else + typedef StdQueueDispatcher ObserveOnDispatcherOp; +#endif + + template + std::shared_ptr> ObserveOnDispatcher( + const std::shared_ptr>& source) + { + auto dispatcher = std::make_shared(); + + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + *cancel = true; + })); + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + dispatcher->post([=]{ + if (!*cancel) + observer->OnNext(element); + }); + }, + // on completed + [=] + { + dispatcher->post([=]{ + if(!*cancel) + observer->OnCompleted(); + }); + }, + // on error + [=](const std::exception_ptr& error) + { + dispatcher->post([=]{ + if (!*cancel) + observer->OnError(error); + }); + })); + return cd; + }); + } + +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-scheduler.h b/Rx/CPP/src/cpprx/rx-scheduler.h new file mode 100644 index 0000000..c2c16d6 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-scheduler.h @@ -0,0 +1,395 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_SCHEDULERS_HPP) +#define CPPRX_RX_SCHEDULERS_HPP +#pragma once + +namespace rxcpp +{ + + ////////////////////////////////////////////////////////////////////// + // + // schedulers + + struct CurrentThreadScheduler : public LocalScheduler + { + private: + CurrentThreadScheduler(const CurrentThreadScheduler&); + + struct compare_work + { + template + bool operator()(const T& work1, const T& work2) const { + return work1.first > work2.first; + } + }; + + typedef std::priority_queue< + std::pair>, + std::vector>>, + compare_work + > ScheduledWork; + + RXCPP_THREAD_LOCAL static ScheduledWork* scheduledWork; + + public: + CurrentThreadScheduler() + { + } + virtual ~CurrentThreadScheduler() + { + } + + static bool IsScheduleRequired() { return scheduledWork == nullptr; } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto cancelable = std::make_shared(std::move(work)); + // check trampoline + if (!!scheduledWork) + { + scheduledWork->push(std::make_pair(dueTime, cancelable)); + return Disposable([=]{(*cancelable.get()) = nullptr;}); + } + + // create and publish new queue + scheduledWork = new ScheduledWork(); + RXCPP_UNWIND_AUTO([]{ + delete scheduledWork; + scheduledWork = nullptr; + }); + + scheduledWork->push(std::make_pair(dueTime, cancelable)); + + // loop until queue is empty + for ( + auto dueTime = scheduledWork->top().first; + std::this_thread::sleep_until(dueTime), true; + dueTime = scheduledWork->top().first + ) + { + // dispatch work + auto work = std::move(*scheduledWork->top().second.get()); + scheduledWork->pop(); + + Do(work, get()); + + if (scheduledWork->empty()) {break;} + } + + return Disposable::Empty(); + } + }; + // static + RXCPP_SELECT_ANY RXCPP_THREAD_LOCAL CurrentThreadScheduler::ScheduledWork* CurrentThreadScheduler::scheduledWork = nullptr; + + struct ImmediateScheduler : public LocalScheduler + { + private: + ImmediateScheduler(const ImmediateScheduler&); + + public: + ImmediateScheduler() + { + } + virtual ~ImmediateScheduler() + { + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto ct = std::make_shared(); + Do(work, ct); + return Disposable::Empty(); + } + }; + + + class WorkQueue : public std::enable_shared_from_this + { + typedef LocalScheduler::Work Work; + typedef LocalScheduler::clock clock; + typedef std::pair Item; + typedef std::shared_ptr shared; + + struct compare_work + { + template + bool operator()(const T& work1, const T& work2) const { + return work1.first > work2.first; + } + }; + + std::atomic trampoline; + std::priority_queue< + std::pair>, + std::vector>>, + compare_work > scheduledWork; + mutable std::mutex lock; + mutable std::condition_variable wake; + mutable std::atomic exit; + + struct WorkQueueScheduler : public LocalScheduler + { + private: + WorkQueueScheduler(); + WorkQueueScheduler(const WorkQueueScheduler&); + + WorkQueue::shared queue; + + public: + WorkQueueScheduler(WorkQueue::shared queue) : queue(queue) + { + } + virtual ~WorkQueueScheduler() + { + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto cancelable = std::make_shared(std::make_pair(get(), std::move(work))); + { + std::unique_lock guard(queue->lock); + queue->scheduledWork.push(std::make_pair(dueTime, cancelable)); + } + queue->wake.notify_one(); + auto local = queue; + return Disposable([local, cancelable]{ + std::unique_lock guard(local->lock); + cancelable.get()->second = nullptr;}); + } + }; + + public: + typedef std::function RunLoop; + typedef std::function Factory; + + WorkQueue() + : trampoline(0) + , exit(false) + { + } + + util::maybe EnsureThread(Factory& factory) + { + util::maybe result; + std::unique_lock guard(lock); + RXCPP_UNWIND(unwindTrampoline, [&]{--trampoline;}); + if (++trampoline == 1) + { + auto local = shared_from_this(); + result.set(factory([local]{local->Run();})); + // trampoline lifetime is now owned by the thread + unwindTrampoline.dismiss(); + } + return result; + } + + void Dispose() const + { + std::unique_lock guard(lock); + if (trampoline > 0) + { + exit = true; + wake.notify_one(); + } + } + operator Disposable() const + { + auto local = shared_from_this(); + return Disposable([local]{ + local->Dispose(); + }); + } + Scheduler::shared GetScheduler() + { + return std::make_shared(shared_from_this()); + } + void Run() + { + auto keepAlive = shared_from_this(); + { + RXCPP_UNWIND_AUTO([&]{--trampoline;}); + + std::unique_lock guard(lock); + + while(!exit && !scheduledWork.empty()) + { + // wait until there is work + wake.wait(guard, [this]{ return this->exit || !this->scheduledWork.empty();}); + if (exit || scheduledWork.empty()) {break;} + + auto item = &scheduledWork.top(); + if (!item->second) {scheduledWork.pop(); continue;} + + // wait until the work is due + while (!exit && item->second && item->second.get()->first->Now() < item->first) + { + wake.wait_until(guard, item->first); + item = &scheduledWork.top(); + } + if (exit || scheduledWork.empty()) {break;} + if (!item->second) {scheduledWork.pop(); continue;} + + // dispatch work + auto work = std::move(item->second.get()->second); + auto scheduler = std::move(item->second.get()->first); + scheduledWork.pop(); + + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + LocalScheduler::Do(work, scheduler); + } + } + exit = false; + } + + Disposable RunOnScheduler(Scheduler::shared scheduler) + { + RXCPP_UNWIND_AUTO([&]{--trampoline;}); + if (++trampoline == 1) + { + // this is decremented when no further work is scheduled + ++trampoline; + auto keepAlive = shared_from_this(); + return scheduler->Schedule( + [keepAlive, scheduler](Scheduler::shared){ + return keepAlive->RunOnSchedulerWork(scheduler);}); + } + return Disposable::Empty(); + } + private: + Disposable RunOnSchedulerWork(Scheduler::shared scheduler) + { + auto keepAlive = shared_from_this(); + + std::unique_lock guard(lock); + + if(!exit && !scheduledWork.empty()) + { + auto& item = scheduledWork.top(); + + // wait until the work is due + if(!exit && item.second.get()->first->Now() < item.first) + { + return scheduler->Schedule( + item.first, + [keepAlive, scheduler](Scheduler::shared){ + return keepAlive->RunOnSchedulerWork(scheduler);}); + } + + if(!exit) + { + // dispatch work + auto work = std::move(item.second.get()->second); + auto scheduler = std::move(item.second.get()->first); + scheduledWork.pop(); + + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + LocalScheduler::Do(work, scheduler); + } + } + + if(!exit && !scheduledWork.empty()) + { + return scheduler->Schedule( + [keepAlive, scheduler](Scheduler::shared){ + return keepAlive->RunOnSchedulerWork(scheduler);}); + } + + // only decrement when no further work is scheduled + --trampoline; + exit = false; + return Disposable::Empty(); + } + }; + + + struct EventLoopScheduler : public LocalScheduler + { + private: + EventLoopScheduler(const EventLoopScheduler&); + + std::shared_ptr queue; + Scheduler::shared scheduler; + std::thread worker; + WorkQueue::Factory factory; + + public: + EventLoopScheduler() + : queue(std::make_shared()) + , scheduler(queue->GetScheduler()) + { + auto local = queue; + factory = [local] (WorkQueue::RunLoop rl) -> std::thread { + return std::thread([local, rl]{rl();}); + }; + } + template + EventLoopScheduler(Factory factoryarg) + : queue(std::make_shared()) + , scheduler(queue->GetScheduler()) + { + auto local = queue; + factory = std::move(factoryarg); + } + virtual ~EventLoopScheduler() + { + if (worker.joinable()) { + worker.detach(); + } + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + Disposable result = scheduler->Schedule(dueTime, std::move(work)); + + auto maybeThread = queue->EnsureThread(factory); + if (maybeThread) + { + if (worker.joinable()) + { + worker.join(); + } + worker = std::move(*maybeThread.get()); + } + return std::move(result); + } + }; + + struct NewThreadScheduler : public LocalScheduler + { + public: + typedef std::function)> Factory; + private: + NewThreadScheduler(const NewThreadScheduler&); + + Factory factory; + public: + + + NewThreadScheduler() : factory([](std::function start){return std::thread(std::move(start));}) + { + } + NewThreadScheduler(Factory factory) : factory(factory) + { + } + virtual ~NewThreadScheduler() + { + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto scheduler = std::make_shared(factory); + return scheduler->Schedule(dueTime, work); + } + }; +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index d1f69c7..32c4cd0 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -12,6 +12,14 @@ #endif #endif +#if !defined(RXCPP_SELECT_ANY) +#if defined(_MSC_VER) +#define RXCPP_SELECT_ANY __declspec(selectany) +#else +#define RXCPP_SELECT_ANY +#endif +#endif + #define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix #define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) @@ -26,7 +34,107 @@ namespace rxcpp { namespace util { Type operator()(const Type& left) const {return left;} }; - template + template + class maybe + { + bool is_set; + typename std::aligned_storage::value>::type + storage; + public: + maybe() + : is_set(false) + { + } + + maybe(T value) + : is_set(false) + { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + + maybe(const maybe& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(*other.get()); + is_set = true; + } + } + maybe(maybe&& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(std::move(*other.get())); + is_set = true; + other.reset(); + } + } + + ~maybe() + { + reset(); + } + + void reset() + { + if (is_set) { + is_set = false; + reinterpret_cast(&storage)->~T(); + } + } + + T* get() { + return is_set ? reinterpret_cast(&storage) : 0; + } + + const T* get() const { + return is_set ? reinterpret_cast(&storage) : 0; + } + + void set(const T& value) { + if (is_set) { + *reinterpret_cast(&storage) = value; + } else { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + } + void set(T&& value) { + if (is_set) { + *reinterpret_cast(&storage) = std::move(value); + } else { + new (reinterpret_cast(&storage)) T(std::move(value)); + is_set = true; + } + } + + T& operator*() { return *get(); } + const T& operator*() const { return *get(); } + T* operator->() { return get(); } + const T* operator->() const { return get(); } + + maybe& operator=(const T& other) { + set(other); + } + maybe& operator=(const maybe& other) { + if (const T* pother = other.get()) { + set(*pother); + } else { + reset(); + } + return *this; + } + + // boolean-like operators + operator T*() { return get(); } + operator const T*() const { return get(); } + + private: + + }; + + template class unwinder { public: diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index b20c645..2c9bac9 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -9,10 +9,12 @@ #define NOMINMAX #include -namespace rxcpp -{ +namespace rxcpp { namespace win32 { + -#define OBSERVE_ON_DISPATCHER_OP +#if !defined(OBSERVE_ON_DISPATCHER_OP) +#define OBSERVE_ON_DISPATCHER_OP rxcpp::win32::ObserveOnDispatcherOp +#endif struct ObserveOnDispatcherOp { @@ -73,21 +75,96 @@ namespace rxcpp template void post(Fn fn) const { - auto p = new Fn(fn); - ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + std::unique_ptr f(new Fn(fn)); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)f.release()); } template static void run_proc( void* pvfn ) { - auto fn = (Fn*)(void*) pvfn; - (*fn)(); - delete fn; + std::unique_ptr f((Fn*)(void*) pvfn); + (*f.get())(); } }; -} + class WindowScheduler : public rxcpp::LocalScheduler + { + HWND hwnd; + Scheduler::shared ct; + typedef std::pair Item; + + struct WindowClass + { + static const wchar_t* const className(){ return L"rxcpp::win32::WindowScheduler::WindowClass"; } + WindowClass() + { + WNDCLASS wndclass = {}; + wndclass.style = 0; + wndclass.lpfnWndProc = &WndProc; + wndclass.cbClsExtra; + wndclass.cbWndExtra = 0; + wndclass.hInstance = NULL; + wndclass.lpszClassName = className(); + + if (!RegisterClass(&wndclass)) + throw std::exception("failed to register windows class"); + + } + HWND CreateWindow_() + { + return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + } + static const int WM_USER_DISPATCH = WM_USER + 1; + + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + { + switch (message) + { + // TODO: shatter attack surface. should validate the message, e.g. using a handle table. + case WM_USER_DISPATCH: + ((void(*)(void*))wParam)((void*)lParam); + return 0; + default: + return DefWindowProc(hwnd, message, wParam, lParam); + } + } + static WindowClass& Instance() { + static WindowClass instance; + return instance; + } + }; + static void run_proc( + void* pvfn + ) + { + std::unique_ptr f((Item*)(void*) pvfn); + Do(f->second, f->first); + } + + public: + WindowScheduler() + : hwnd(WindowClass::Instance().CreateWindow_()) + , ct(std::make_shared()) + { + if (!hwnd) + throw std::exception("create window failed"); + } + ~WindowScheduler() + { + // send one last message to ourselves to shutdown. + Schedule([=](Scheduler::shared){ CloseWindow(hwnd); return Disposable::Empty();}); + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + std::unique_ptr f(new Item(ct, std::move(work))); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)f.release()); + return Disposable::Empty(); + } + }; +} } #endif diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 6d8ffd9..f596bd0 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -27,8 +27,10 @@ #include "rx-util.hpp" -#include "rx-windows.hpp" #include "rx-base.hpp" +#include "rx-scheduler.h" +#include "rx-windows.hpp" +#include "rx-operators.hpp" namespace rxcpp { @@ -52,8 +54,11 @@ namespace rxcpp auto take(Integral n) -> decltype(from(Take(obj, n))) { return from(Take(obj, n)); } - auto delay(int milliseconds) -> decltype(from(Delay(obj, milliseconds))) { - return from(Delay(obj, milliseconds)); + auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { + return from(Delay(obj, due)); + } + auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { + return from(Delay(obj, due, scheduler)); } auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { return from(LimitWindow(obj, milliseconds)); @@ -61,6 +66,16 @@ namespace rxcpp auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } + auto subscribe_on(Scheduler::shared scheduler) + -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) + { + return from(SubscribeOnObservable(obj, std::move(scheduler))); + } + auto observe_on(Scheduler::shared scheduler) + -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) + { + return from(ObserveOnObserver(obj, std::move(scheduler))); + } auto on_dispatcher() -> decltype(from(ObserveOnDispatcher(obj))) { @@ -68,24 +83,18 @@ namespace rxcpp } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - DefaultScheduler::Instance().ScopeEnter(); auto result = Subscribe(obj, onNext); - DefaultScheduler::Instance().ScopeExit(); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete) -> decltype(Subscribe(obj, onNext, onComplete)) { - DefaultScheduler::Instance().ScopeEnter(); auto result = Subscribe(obj, onNext, onComplete); - DefaultScheduler::Instance().ScopeExit(); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) -> decltype(Subscribe(obj, onNext, onComplete, onError)) { - DefaultScheduler::Instance().ScopeEnter(); auto result = Subscribe(obj, onNext, onComplete, onError); - DefaultScheduler::Instance().ScopeExit(); return result; } }; diff --git a/Rx/CPP/testbench/data.txt b/Rx/CPP/testbench/data.txt new file mode 100644 index 0000000..b16aea6 --- /dev/null +++ b/Rx/CPP/testbench/data.txt @@ -0,0 +1,655 @@ +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22437888.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.9785421875}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26136576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.956228125}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22503424.0, 'privatemem': 25968640.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 71.741975}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26177536.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.189240625}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22323200.0, 'privatemem': 25808896.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.7897296875}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14917632.0, 'privatemem': 20385792.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.734965625}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15060992.0, 'privatemem': 20545536.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.028878125}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15052800.0, 'privatemem': 20529152.0, 'nonpaged': 26768.0, 'virtualmem': 577224704.0, 'time': 45.5304375}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14934016.0, 'privatemem': 20406272.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.898271875}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14991360.0, 'privatemem': 20447232.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.425371875}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 32.748084375}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26202112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.5510765625}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22556672.0, 'privatemem': 26021888.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.0404453125}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26038272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 34.0872890625}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25976832.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.026740625}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15093760.0, 'privatemem': 21082112.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 23.0056984375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20918272.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2537171875}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20905984.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2316484375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15192064.0, 'privatemem': 20910080.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.259509375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 20979712.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.3385359375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25952256.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2717265625}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2175609375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26042368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.07530625}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.281884375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26185728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.05386875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15245312.0, 'privatemem': 21233664.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.3586671875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15310848.0, 'privatemem': 21250048.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.70775625}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15347712.0, 'privatemem': 21254144.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.6456703125}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 21180416.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.303421875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15335424.0, 'privatemem': 21299200.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.4817796875}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 25980928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7404328125}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22482944.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2058328125}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22646784.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 17.3264390625}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.233396875}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.4778453125}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15200256.0, 'privatemem': 21196800.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 12.3187859375}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15474688.0, 'privatemem': 21725184.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 11.6904421875}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15384576.0, 'privatemem': 21630976.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.795390625}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15364096.0, 'privatemem': 21606400.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.5224484375}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15343616.0, 'privatemem': 21590016.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.4604203125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22536192.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.291790625}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22753280.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8192703125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25919488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1479078125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22728704.0, 'privatemem': 26058752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7772765625}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4325453125}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15458304.0, 'privatemem': 21950464.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 11.653565625}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15622144.0, 'privatemem': 22114304.0, 'nonpaged': 28688.0, 'virtualmem': 610779136.0, 'time': 11.60025}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15491072.0, 'privatemem': 21975040.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 15.956359375}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15429632.0, 'privatemem': 21938176.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 16.7639015625}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15560704.0, 'privatemem': 22102016.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 12.432678125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.482378125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22724608.0, 'privatemem': 26005504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.6995578125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22601728.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7111109375}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22675456.0, 'privatemem': 26017792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.24071875}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22822912.0, 'privatemem': 26206208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1442453125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15446016.0, 'privatemem': 22118400.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.3196953125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15351808.0, 'privatemem': 21860352.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 13.8507890625}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15536128.0, 'privatemem': 22384640.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.411578125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15728640.0, 'privatemem': 22585344.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.3764765625}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22331392.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.253040625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22650880.0, 'privatemem': 25956352.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1586765625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22700032.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2853515625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9393859375}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22597632.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.95501875}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22794240.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.9703578125}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15720448.0, 'privatemem': 22822912.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.88916875}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15872000.0, 'privatemem': 22978560.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.7966875}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15642624.0, 'privatemem': 22474752.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.072915625}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15605760.0, 'privatemem': 22548480.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.3262265625}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15503360.0, 'privatemem': 22335488.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.3073703125}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26075136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7767140625}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22683648.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.6023046875}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.590659375}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26128384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.797509375}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26001408.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.114903125}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15843328.0, 'privatemem': 23093248.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.8031640625}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22933504.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.78183125}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15626240.0, 'privatemem': 22466560.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.79186875}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15998976.0, 'privatemem': 23089152.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.6507984375}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15769600.0, 'privatemem': 22892544.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.7464046875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26107904.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5812421875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26030080.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.8055078125}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 23019520.0, 'privatemem': 26374144.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.661046875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22810624.0, 'privatemem': 26165248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8447890625}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26157056.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7037859375}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15937536.0, 'privatemem': 23482368.0, 'nonpaged': 30384.0, 'virtualmem': 640139264.0, 'time': 9.9560078125}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22953984.0, 'nonpaged': 29888.0, 'virtualmem': 631750656.0, 'time': 9.9779875}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15806464.0, 'privatemem': 23216128.0, 'nonpaged': 30144.0, 'virtualmem': 635944960.0, 'time': 10.0446703125}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15765504.0, 'privatemem': 23171072.0, 'nonpaged': 30128.0, 'virtualmem': 635944960.0, 'time': 9.8954875}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22679552.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.1007609375}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4936453125}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.54201875}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8461453125}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5201171875}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26173440.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.7564125}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16015360.0, 'privatemem': 23687168.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.308821875}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15978496.0, 'privatemem': 23896064.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3545609375}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16105472.0, 'privatemem': 23773184.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.39604375}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16003072.0, 'privatemem': 23670784.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 11.3077953125}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23347200.0, 'nonpaged': 30272.0, 'virtualmem': 640139264.0, 'time': 11.2470921875}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26017792.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.5840734375}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22843392.0, 'privatemem': 26238976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.7056515625}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22765568.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.4621296875}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.7261640625}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22659072.0, 'privatemem': 26132480.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.43949375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24227840.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 10.1509875}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23486464.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.4571375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15953920.0, 'privatemem': 23937024.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.21300625}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16056320.0, 'privatemem': 24068096.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3364984375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15851520.0, 'privatemem': 23621632.0, 'nonpaged': 30752.0, 'virtualmem': 648527872.0, 'time': 10.205690625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4346625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22941696.0, 'privatemem': 26288128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.588709375}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25997312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.383815625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22818816.0, 'privatemem': 26148864.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.60400625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22716416.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3768921875}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16101376.0, 'privatemem': 24428544.0, 'nonpaged': 31712.0, 'virtualmem': 665305088.0, 'time': 9.846940625}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16089088.0, 'privatemem': 24199168.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 11.1524609375}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16199680.0, 'privatemem': 24178688.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 9.9980328125}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16023552.0, 'privatemem': 23977984.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 11.2873078125}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24387584.0, 'nonpaged': 31472.0, 'virtualmem': 661110784.0, 'time': 9.934396875}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22781952.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4010015625}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25985024.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2167890625}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26152960.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.4800796875}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26050560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.449178125}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26058752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2931078125}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16310272.0, 'privatemem': 25399296.0, 'nonpaged': 32912.0, 'virtualmem': 686276608.0, 'time': 10.06823125}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16154624.0, 'privatemem': 24883200.0, 'nonpaged': 32432.0, 'virtualmem': 677888000.0, 'time': 10.0306984375}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16171008.0, 'privatemem': 25038848.0, 'nonpaged': 32672.0, 'virtualmem': 682082304.0, 'time': 10.06961875}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16216064.0, 'privatemem': 24817664.0, 'nonpaged': 32192.0, 'virtualmem': 673693696.0, 'time': 10.0746796875}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16375808.0, 'privatemem': 25542656.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 10.037271875}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25985024.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4086859375}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3663890625}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26034176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3019828125}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26144768.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.389559375}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22593536.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2155328125}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16252928.0, 'privatemem': 25710592.0, 'nonpaged': 33632.0, 'virtualmem': 698859520.0, 'time': 9.93735}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16265216.0, 'privatemem': 25427968.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.9944796875}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16236544.0, 'privatemem': 25595904.0, 'nonpaged': 33392.0, 'virtualmem': 694665216.0, 'time': 9.94461875}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16257024.0, 'privatemem': 25403392.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.94913125}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16424960.0, 'privatemem': 26009600.0, 'nonpaged': 33872.0, 'virtualmem': 703053824.0, 'time': 9.9931234375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26169344.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.376209375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22528000.0, 'privatemem': 25866240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2378046875}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26128384.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.225084375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 26038272.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.23915625}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26140672.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.35693125}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16650240.0, 'privatemem': 26861568.0, 'nonpaged': 34832.0, 'virtualmem': 719831040.0, 'time': 9.7327859375}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16547840.0, 'privatemem': 26378240.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.775103125}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16654336.0, 'privatemem': 26513408.0, 'nonpaged': 34472.0, 'virtualmem': 713539584.0, 'time': 9.8092875}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16445440.0, 'privatemem': 26304512.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.834784375}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16510976.0, 'privatemem': 26243072.0, 'nonpaged': 34112.0, 'virtualmem': 707248128.0, 'time': 9.9615171875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.234246875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26140672.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1942140625}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26079232.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3161734375}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22708224.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2072671875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2228828125}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16568320.0, 'privatemem': 27033600.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8727921875}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16764928.0, 'privatemem': 27238400.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8168890625}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16842752.0, 'privatemem': 27193344.0, 'nonpaged': 35192.0, 'virtualmem': 726122496.0, 'time': 9.8725515625}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16732160.0, 'privatemem': 27230208.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8796578125}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16576512.0, 'privatemem': 26882048.0, 'nonpaged': 35072.0, 'virtualmem': 724025344.0, 'time': 9.851103125}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22679552.0, 'privatemem': 25993216.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.183775}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1523140625}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2646}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26025984.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.190975}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26173440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.290859375}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17313792.0, 'privatemem': 29270016.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 9.8081125}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17297408.0, 'privatemem': 29560832.0, 'nonpaged': 38672.0, 'virtualmem': 786939904.0, 'time': 9.803896875}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17514496.0, 'privatemem': 29667328.0, 'nonpaged': 38552.0, 'virtualmem': 784842752.0, 'time': 10.44371875}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17350656.0, 'privatemem': 29356032.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 10.5586140625}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17219584.0, 'privatemem': 29265920.0, 'nonpaged': 38072.0, 'virtualmem': 776454144.0, 'time': 11.02230625}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29392896.0, 'privatemem': 32837632.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.5534375}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32817152.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.04296875}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29323264.0, 'privatemem': 32690176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5768078125}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29327360.0, 'privatemem': 32718848.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1712328125}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.193025}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17764352.0, 'privatemem': 30863360.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7636984375}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17707008.0, 'privatemem': 30818304.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7707}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17625088.0, 'privatemem': 30760960.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.812396875}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17649664.0, 'privatemem': 30711808.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 10.313584375}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17674240.0, 'privatemem': 30810112.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.8304125}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1279546875}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1256796875}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29585408.0, 'privatemem': 32956416.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.14424375}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29421568.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1787703125}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29347840.0, 'privatemem': 32718848.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121146875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17829888.0, 'privatemem': 32083968.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7840515625}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17981440.0, 'privatemem': 32190464.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.774884375}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17907712.0, 'privatemem': 32178176.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7712421875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17809408.0, 'privatemem': 32092160.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.883371875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 18104320.0, 'privatemem': 32366592.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.8319875}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29380608.0, 'privatemem': 32731136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.139365625}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29401088.0, 'privatemem': 32792576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1221734375}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29298688.0, 'privatemem': 32735232.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3343921875}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29564928.0, 'privatemem': 32948224.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.144190625}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32894976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.147003125}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18358272.0, 'privatemem': 34308096.0, 'nonpaged': 45032.0, 'virtualmem': 898088960.0, 'time': 9.80116875}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18325504.0, 'privatemem': 33714176.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.898659375}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18300928.0, 'privatemem': 33689600.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7784}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18210816.0, 'privatemem': 33574912.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.9189640625}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18202624.0, 'privatemem': 33566720.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7934265625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29495296.0, 'privatemem': 32886784.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.111571875}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29429760.0, 'privatemem': 32776192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.199890625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29442048.0, 'privatemem': 32886784.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.11831875}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29597696.0, 'privatemem': 32931840.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1347890625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32739328.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.171440625}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19292160.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7851578125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19222528.0, 'privatemem': 37990400.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.759603125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19308544.0, 'privatemem': 38092800.0, 'nonpaged': 49928.0, 'virtualmem': 981975040.0, 'time': 9.73698125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19214336.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7582359375}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19324928.0, 'privatemem': 38129664.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7412640625}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29474816.0, 'privatemem': 32837632.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.169203125}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29614080.0, 'privatemem': 32976896.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1191375}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29626368.0, 'privatemem': 32968704.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1113484375}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 33058816.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.1464140625}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32747520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1111234375}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 20041728.0, 'privatemem': 41103360.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.7898}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19968000.0, 'privatemem': 41009152.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.855309375}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19824640.0, 'privatemem': 40890368.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9260921875}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19947520.0, 'privatemem': 41054208.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9416703125}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19808256.0, 'privatemem': 40882176.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.8916515625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29691904.0, 'privatemem': 33034240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.11079375}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32755712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1449734375}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29315072.0, 'privatemem': 32628736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13280625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1016015625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32735232.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1100125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20836352.0, 'privatemem': 44212224.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.02668125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20934656.0, 'privatemem': 44322816.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.9877078125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 21037056.0, 'privatemem': 45981696.0, 'nonpaged': 60152.0, 'virtualmem': 1162330112.0, 'time': 9.9358015625}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20824064.0, 'privatemem': 44150784.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.98304375}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20856832.0, 'privatemem': 44257280.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.009546875}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 33009664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.0923984375}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.163709375}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32849920.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1063703125}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29450240.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0826171875}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29528064.0, 'privatemem': 32833536.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.086065625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21835776.0, 'privatemem': 48500736.0, 'nonpaged': 63032.0, 'virtualmem': 1212661760.0, 'time': 10.0842015625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21663744.0, 'privatemem': 47255552.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.0181609375}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21577728.0, 'privatemem': 47198208.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.846165625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21389312.0, 'privatemem': 46759936.0, 'nonpaged': 61112.0, 'virtualmem': 1179107328.0, 'time': 11.5423390625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21254144.0, 'privatemem': 46899200.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 11.306240625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.85168125}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 33005568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.58709375}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32862208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5917140625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32821248.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1530390625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29405184.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08974375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23420928.0, 'privatemem': 55808000.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2232734375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23494656.0, 'privatemem': 55554048.0, 'nonpaged': 72392.0, 'virtualmem': 1376239616.0, 'time': 10.3183484375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23584768.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.3544203125}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23617536.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2523703125}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23609344.0, 'privatemem': 55885824.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.154103125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29544448.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0866078125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29507584.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0993953125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32841728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.10189375}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.0977}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29581312.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0975171875}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24719360.0, 'privatemem': 61693952.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.415759375}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24862720.0, 'privatemem': 61919232.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2971765625}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24784896.0, 'privatemem': 61628416.0, 'nonpaged': 80552.0, 'virtualmem': 1518845952.0, 'time': 10.34406875}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24969216.0, 'privatemem': 61984768.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2925640625}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24752128.0, 'privatemem': 61415424.0, 'nonpaged': 80312.0, 'virtualmem': 1514651648.0, 'time': 10.284221875}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29650944.0, 'privatemem': 33046528.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.15705625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29700096.0, 'privatemem': 33017856.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.122590625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29659136.0, 'privatemem': 33026048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08970625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32915456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1275171875}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32882688.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.14285}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26378240.0, 'privatemem': 67780608.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.4648703125}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26124288.0, 'privatemem': 67293184.0, 'nonpaged': 88112.0, 'virtualmem': 1653063680.0, 'time': 10.5292671875}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26046464.0, 'privatemem': 67276800.0, 'nonpaged': 87992.0, 'virtualmem': 1648869376.0, 'time': 10.491190625}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26034176.0, 'privatemem': 67489792.0, 'nonpaged': 88232.0, 'virtualmem': 1653063680.0, 'time': 10.5243890625}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26234880.0, 'privatemem': 67649536.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.5925109375}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32944128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.150478125}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29741056.0, 'privatemem': 33099776.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1190796875}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 33005568.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.178025}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32948224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1318578125}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29933568.0, 'privatemem': 33325056.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 13.130896875}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27303936.0, 'privatemem': 73404416.0, 'nonpaged': 96272.0, 'virtualmem': 1795670016.0, 'time': 10.5394765625}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27607040.0, 'privatemem': 73625600.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.565934375}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27287552.0, 'privatemem': 72835072.0, 'nonpaged': 95552.0, 'virtualmem': 1783087104.0, 'time': 10.6236890625}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27480064.0, 'privatemem': 73379840.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.57548125}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27201536.0, 'privatemem': 73240576.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.68160625}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29671424.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.175703125}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29827072.0, 'privatemem': 33165312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1375234375}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29777920.0, 'privatemem': 33116160.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121140625}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 32870400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1075078125}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29704192.0, 'privatemem': 33001472.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.150696875}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29577216.0, 'privatemem': 84500480.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.8671703125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29835264.0, 'privatemem': 84918272.0, 'nonpaged': 111392.0, 'virtualmem': 2059911168.0, 'time': 10.893078125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29667328.0, 'privatemem': 84197376.0, 'nonpaged': 110672.0, 'virtualmem': 2047328256.0, 'time': 10.899709375}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29663232.0, 'privatemem': 84520960.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.9027828125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 84615168.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.904421875}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 32960512.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.132984375}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29839360.0, 'privatemem': 33132544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13160625}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29978624.0, 'privatemem': 33378304.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.1281796875}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33095680.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1194140625}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29880320.0, 'privatemem': 33148928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.140121875}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32329728.0, 'privatemem': 96473088.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.03265625}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32165888.0, 'privatemem': 96047104.0, 'nonpaged': 126272.0, 'virtualmem': 2319958016.0, 'time': 11.1066328125}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32178176.0, 'privatemem': 96284672.0, 'nonpaged': 126512.0, 'virtualmem': 2324152320.0, 'time': 11.0177765625}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32161792.0, 'privatemem': 96284672.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.15135}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32096256.0, 'privatemem': 96309248.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.1041015625}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33148928.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.127125}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29913088.0, 'privatemem': 33284096.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1395265625}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29921280.0, 'privatemem': 33263616.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.136646875}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29761536.0, 'privatemem': 33140736.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1379828125}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29818880.0, 'privatemem': 33173504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.7975015625}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34549760.0, 'privatemem': 107462656.0, 'nonpaged': 141632.0, 'virtualmem': 2588393472.0, 'time': 12.9889609375}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34643968.0, 'privatemem': 108085248.0, 'nonpaged': 142352.0, 'virtualmem': 2600976384.0, 'time': 13.0880796875}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34697216.0, 'privatemem': 107810816.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 13.2690765625}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34508800.0, 'privatemem': 107683840.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 12.4901671875}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34443264.0, 'privatemem': 107638784.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 11.23786875}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29847552.0, 'privatemem': 33222656.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.127740625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29859840.0, 'privatemem': 33206272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22630625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29896704.0, 'privatemem': 33259520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1849640625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29884416.0, 'privatemem': 33206272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.13985}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33333248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1424328125}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37142528.0, 'privatemem': 119185408.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.397996875}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37056512.0, 'privatemem': 119328768.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.38355}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37068800.0, 'privatemem': 119164928.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.4034015625}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37187584.0, 'privatemem': 119382016.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.341525}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37076992.0, 'privatemem': 119296000.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.373334375}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30105600.0, 'privatemem': 33378304.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.18291875}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30064640.0, 'privatemem': 33406976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.201753125}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30154752.0, 'privatemem': 33447936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1939015625}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30044160.0, 'privatemem': 33349632.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2285859375}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30068736.0, 'privatemem': 33341440.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1834984375}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47366144.0, 'privatemem': 141705216.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.7742625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47321088.0, 'privatemem': 141434880.0, 'nonpaged': 187712.0, 'virtualmem': 3393699840.0, 'time': 11.8519890625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47198208.0, 'privatemem': 141729792.0, 'nonpaged': 188432.0, 'virtualmem': 3406282752.0, 'time': 11.8748625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47349760.0, 'privatemem': 141578240.0, 'nonpaged': 187952.0, 'virtualmem': 3397894144.0, 'time': 11.80855625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47333376.0, 'privatemem': 141635584.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.8793171875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30441472.0, 'privatemem': 33677312.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1907140625}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30380032.0, 'privatemem': 33607680.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.224996875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30326784.0, 'privatemem': 33628160.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1955234375}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30355456.0, 'privatemem': 33726464.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 13.1947671875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30322688.0, 'privatemem': 33738752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2064796875}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52543488.0, 'privatemem': 163958784.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 11.974178125}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52502528.0, 'privatemem': 164315136.0, 'nonpaged': 219512.0, 'virtualmem': 3955736576.0, 'time': 11.9167046875}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52707328.0, 'privatemem': 164122624.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.118128125}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52293632.0, 'privatemem': 163651584.0, 'nonpaged': 218792.0, 'virtualmem': 3943153664.0, 'time': 12.049109375}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52748288.0, 'privatemem': 163999744.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.0723515625}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30642176.0, 'privatemem': 33882112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1681703125}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30302208.0, 'privatemem': 33697792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1825015625}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30408704.0, 'privatemem': 33726464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2253203125}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30486528.0, 'privatemem': 33800192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.250696875}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30560256.0, 'privatemem': 33894400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.174471875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58105856.0, 'privatemem': 186347520.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.09041875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57851904.0, 'privatemem': 186142720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9983140625}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57663488.0, 'privatemem': 185761792.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.26386875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57929728.0, 'privatemem': 186257408.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9970984375}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58085376.0, 'privatemem': 186654720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 12.0862875}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30867456.0, 'privatemem': 34107392.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2160328125}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30945280.0, 'privatemem': 34258944.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.2101375}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31059968.0, 'privatemem': 34291712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3171546875}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31064064.0, 'privatemem': 34279424.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2282890625}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31006720.0, 'privatemem': 34263040.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.209078125}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63021056.0, 'privatemem': 208171008.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 13.048375}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63369216.0, 'privatemem': 208424960.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.2770109375}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63447040.0, 'privatemem': 208539648.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.228196875}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63488000.0, 'privatemem': 208715776.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.670853125}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63070208.0, 'privatemem': 208207872.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.4422}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31617024.0, 'privatemem': 34848768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2811921875}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31719424.0, 'privatemem': 34897920.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22355625}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31494144.0, 'privatemem': 34746368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22349375}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31694848.0, 'privatemem': 34947072.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2325609375}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31547392.0, 'privatemem': 34807808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.767953125}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 73158656.0, 'privatemem': 252420096.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 15.0598109375}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 65974272.0, 'privatemem': 252903424.0, 'nonpaged': 342152.0, 'virtualmem': 6099025920.0, 'time': 13.8913953125}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66895872.0, 'privatemem': 253501440.0, 'nonpaged': 342632.0, 'virtualmem': 6107414528.0, 'time': 13.2943546875}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 67772416.0, 'privatemem': 252964864.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.7788609375}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66498560.0, 'privatemem': 252874752.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.8031625}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24178688.0, 'privatemem': 27402240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.357275}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23916544.0, 'privatemem': 27070464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3384296875}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24154112.0, 'privatemem': 27303936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3860484375}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24080384.0, 'privatemem': 27303936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.40868125}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23764992.0, 'privatemem': 26914816.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3454890625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74870784.0, 'privatemem': 296960000.0, 'nonpaged': 403512.0, 'virtualmem': 7172767744.0, 'time': 13.6358265625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 84811776.0, 'privatemem': 298262528.0, 'nonpaged': 403832.0, 'virtualmem': 7176962048.0, 'time': 14.18599375}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75407360.0, 'privatemem': 296779776.0, 'nonpaged': 403592.0, 'virtualmem': 7172767744.0, 'time': 13.6721390625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75026432.0, 'privatemem': 296505344.0, 'nonpaged': 403112.0, 'virtualmem': 7164379136.0, 'time': 13.3102890625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74461184.0, 'privatemem': 296538112.0, 'nonpaged': 403272.0, 'virtualmem': 7168573440.0, 'time': 14.0042234375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24694784.0, 'privatemem': 27824128.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3436484375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24739840.0, 'privatemem': 27815936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3563359375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24772608.0, 'privatemem': 27918336.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4315375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24756224.0, 'privatemem': 27865088.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.345803125}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24608768.0, 'privatemem': 27750400.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.402634375}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95748096.0, 'privatemem': 343252992.0, 'nonpaged': 465312.0, 'virtualmem': 8267284480.0, 'time': 14.8233890625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 96260096.0, 'privatemem': 343367680.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.9048890625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95764480.0, 'privatemem': 342867968.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.65851875}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95637504.0, 'privatemem': 342515712.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.7174265625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95924224.0, 'privatemem': 342884352.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.8882921875}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25047040.0, 'privatemem': 28094464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3807953125}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24981504.0, 'privatemem': 28151808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.398909375}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25075712.0, 'privatemem': 28147712.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.359221875}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25006080.0, 'privatemem': 28098560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3784}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24997888.0, 'privatemem': 28069888.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3560390625}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 105529344.0, 'privatemem': 386404352.0, 'nonpaged': 526512.0, 'virtualmem': 9336832000.0, 'time': 15.17243125}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106209280.0, 'privatemem': 387317760.0, 'nonpaged': 526992.0, 'virtualmem': 9345220608.0, 'time': 15.41375625}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 107094016.0, 'privatemem': 388059136.0, 'nonpaged': 526752.0, 'virtualmem': 9341026304.0, 'time': 15.4270546875}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106483712.0, 'privatemem': 387428352.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.0365046875}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106057728.0, 'privatemem': 386617344.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.11465}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28733440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4772109375}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29986816.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.39680625}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33005568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.43141875}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28782592.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4375484375}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29941760.0, 'privatemem': 33050624.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 13.40918125}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 124895232.0, 'privatemem': 473268224.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.8352921875}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125243392.0, 'privatemem': 474202112.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.9860609375}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 126054400.0, 'privatemem': 474787840.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.8798015625}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125100032.0, 'privatemem': 473649152.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.90209375}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 127406080.0, 'privatemem': 482037760.0, 'nonpaged': 658512.0, 'virtualmem': 11643699200.0, 'time': 16.0772640625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30760960.0, 'privatemem': 33771520.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.4638640625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30720000.0, 'privatemem': 33730560.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4992015625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30593024.0, 'privatemem': 33632256.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.460190625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30691328.0, 'privatemem': 33710080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.584534375}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30756864.0, 'privatemem': 33738752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.8325828125}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145821696.0, 'privatemem': 562421760.0, 'nonpaged': 772032.0, 'virtualmem': 13627604992.0, 'time': 18.0121359375}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145391616.0, 'privatemem': 562782208.0, 'nonpaged': 772416.0, 'virtualmem': 13635993600.0, 'time': 16.273371875}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145211392.0, 'privatemem': 561577984.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.684478125}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145367040.0, 'privatemem': 561598464.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.70395}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145969152.0, 'privatemem': 562495488.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.7380234375}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31399936.0, 'privatemem': 34484224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5152703125}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31645696.0, 'privatemem': 34541568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5179421875}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31395840.0, 'privatemem': 34435072.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.486846875}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34500608.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5053265625}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31473664.0, 'privatemem': 34447360.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.506196875}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166944768.0, 'privatemem': 650125312.0, 'nonpaged': 895176.0, 'virtualmem': 15795929088.0, 'time': 17.12616875}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166453248.0, 'privatemem': 650084352.0, 'nonpaged': 895656.0, 'virtualmem': 15804317696.0, 'time': 17.1012453125}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166957056.0, 'privatemem': 650522624.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.041084375}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166461440.0, 'privatemem': 651186176.0, 'nonpaged': 896136.0, 'virtualmem': 15812706304.0, 'time': 17.265559375}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166281216.0, 'privatemem': 650743808.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.20788125}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33193984.0, 'privatemem': 36044800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.543359375}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33120256.0, 'privatemem': 35979264.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5913015625}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35794944.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5597421875}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35885056.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.561975}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33013760.0, 'privatemem': 35872768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.552240625}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188612608.0, 'privatemem': 740990976.0, 'nonpaged': 1019232.0, 'virtualmem': 17964384256.0, 'time': 18.23205}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190369792.0, 'privatemem': 742092800.0, 'nonpaged': 1018176.0, 'virtualmem': 17947607040.0, 'time': 18.1267921875}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190291968.0, 'privatemem': 751833088.0, 'nonpaged': 1034976.0, 'virtualmem': 18241208320.0, 'time': 18.278765625}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 187871232.0, 'privatemem': 739778560.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 18.356121875}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188469248.0, 'privatemem': 739135488.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 17.9174328125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34922496.0, 'privatemem': 37539840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.705434375}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37617664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.677278125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37523456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.64224375}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35012608.0, 'privatemem': 37642240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.65468125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35115008.0, 'privatemem': 37711872.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.70276875}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228339712.0, 'privatemem': 915566592.0, 'nonpaged': 1264176.0, 'virtualmem': 22246768640.0, 'time': 19.006409375}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 229093376.0, 'privatemem': 916045824.0, 'nonpaged': 1264296.0, 'virtualmem': 22263349248.0, 'time': 19.33424375}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228802560.0, 'privatemem': 915972096.0, 'nonpaged': 1264184.0, 'virtualmem': 22263349248.0, 'time': 19.201040625}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228282368.0, 'privatemem': 915853312.0, 'nonpaged': 1263936.0, 'virtualmem': 22242574336.0, 'time': 19.1797125}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 227971072.0, 'privatemem': 915865600.0, 'nonpaged': 1264896.0, 'virtualmem': 22259351552.0, 'time': 20.5840234375}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36610048.0, 'privatemem': 39178240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2996234375}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36446208.0, 'privatemem': 39006208.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2134390625}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36413440.0, 'privatemem': 39055360.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.35226875}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36429824.0, 'privatemem': 39075840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8014796875}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36474880.0, 'privatemem': 39116800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7755546875}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 267964416.0, 'privatemem': 1090080768.0, 'nonpaged': 1509464.0, 'virtualmem': 26549927936.0, 'time': 19.5823140625}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 268500992.0, 'privatemem': 1091354624.0, 'nonpaged': 1509816.0, 'virtualmem': 26554122240.0, 'time': 19.5744}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269398016.0, 'privatemem': 1090744320.0, 'nonpaged': 1509576.0, 'virtualmem': 26549927936.0, 'time': 19.7508015625}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269123584.0, 'privatemem': 1093181440.0, 'nonpaged': 1514664.0, 'virtualmem': 26642202624.0, 'time': 19.75071875}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269733888.0, 'privatemem': 1091674112.0, 'nonpaged': 1511384.0, 'virtualmem': 26583482368.0, 'time': 19.5216640625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36532224.0, 'privatemem': 39153664.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.9015625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36720640.0, 'privatemem': 39264256.0, 'nonpaged': 25864.0, 'virtualmem': 564969472.0, 'time': 13.90245}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31596544.0, 'privatemem': 34111488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8932265625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34131968.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.9260484375}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34066432.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.954315625}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 315875328.0, 'privatemem': 1271836672.0, 'nonpaged': 1755264.0, 'virtualmem': 30861475840.0, 'time': 19.696196875}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 312127488.0, 'privatemem': 1268944896.0, 'nonpaged': 1755944.0, 'virtualmem': 30869929984.0, 'time': 19.7884125}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313524224.0, 'privatemem': 1270001664.0, 'nonpaged': 1755344.0, 'virtualmem': 30861475840.0, 'time': 19.5355734375}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313815040.0, 'privatemem': 1271222272.0, 'nonpaged': 1756064.0, 'virtualmem': 30874058752.0, 'time': 19.61661875}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 314990592.0, 'privatemem': 1271472128.0, 'nonpaged': 1755624.0, 'virtualmem': 30865735680.0, 'time': 20.050821875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38105088.0, 'privatemem': 40636416.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.0955625}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37982208.0, 'privatemem': 40583168.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.040196875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38129664.0, 'privatemem': 40685568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.042221875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38043648.0, 'privatemem': 40665088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 14.1191921875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37933056.0, 'privatemem': 40538112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.0314734375}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 356925440.0, 'privatemem': 1448673280.0, 'nonpaged': 2001264.0, 'virtualmem': 35157557248.0, 'time': 20.15775}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 354324480.0, 'privatemem': 1447530496.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.9642671875}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355999744.0, 'privatemem': 1446727680.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.937840625}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355708928.0, 'privatemem': 1447718912.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 21.3836453125}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355086336.0, 'privatemem': 1448427520.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 20.5806625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40574976.0, 'privatemem': 42999808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.212690625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40849408.0, 'privatemem': 43442176.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.26136875}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40611840.0, 'privatemem': 43065344.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2927234375}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 35049472.0, 'privatemem': 37515264.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 14.2932515625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40902656.0, 'privatemem': 43450368.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.29265625}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437157888.0, 'privatemem': 1799569408.0, 'nonpaged': 2493704.0, 'virtualmem': 43789238272.0, 'time': 22.39598125}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 438943744.0, 'privatemem': 1800122368.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3933875}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 454443008.0, 'privatemem': 1816186880.0, 'nonpaged': 2493264.0, 'virtualmem': 43797430272.0, 'time': 22.156965625}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 441925632.0, 'privatemem': 1810481152.0, 'nonpaged': 2503344.0, 'virtualmem': 43973591040.0, 'time': 22.4793375}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437071872.0, 'privatemem': 1798299648.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3045375}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43515904.0, 'privatemem': 45961216.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.59280625}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46112768.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.596046875}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43720704.0, 'privatemem': 46157824.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.590865625}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46100480.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.609971875}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43429888.0, 'privatemem': 45940736.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.6273390625}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 516640768.0, 'privatemem': 2149273600.0, 'nonpaged': 2984784.0, 'virtualmem': 52399816704.0, 'time': 26.321934375}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 517148672.0, 'privatemem': 2152136704.0, 'nonpaged': 2986944.0, 'virtualmem': 52437565440.0, 'time': 26.177103125}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 523063296.0, 'privatemem': 2156064768.0, 'nonpaged': 2985504.0, 'virtualmem': 52412399616.0, 'time': 26.05946875}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 518561792.0, 'privatemem': 2162417664.0, 'nonpaged': 2994864.0, 'virtualmem': 52575977472.0, 'time': 28.18605}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 525058048.0, 'privatemem': 2157924352.0, 'nonpaged': 2985264.0, 'virtualmem': 52408205312.0, 'time': 26.42195625}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40148992.0, 'privatemem': 42582016.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.0295875}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40206336.0, 'privatemem': 42512384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.990478125}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 45486080.0, 'privatemem': 47845376.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9103515625}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 44941312.0, 'privatemem': 47333376.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.9739078125}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 46559232.0, 'privatemem': 49074176.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.99918125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 601858048.0, 'privatemem': 2509008896.0, 'nonpaged': 3485304.0, 'virtualmem': 61158797312.0, 'time': 28.8111328125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 604540928.0, 'privatemem': 2506592256.0, 'nonpaged': 3477504.0, 'virtualmem': 61023174656.0, 'time': 28.554359375}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 607997952.0, 'privatemem': 2508111872.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.05818125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 606982144.0, 'privatemem': 2510180352.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.6098046875}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 603512832.0, 'privatemem': 2506928128.0, 'nonpaged': 3478584.0, 'virtualmem': 61041356800.0, 'time': 30.173225}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42070016.0, 'privatemem': 44314624.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2156484375}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42672128.0, 'privatemem': 44982272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 16.160125}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42905600.0, 'privatemem': 45236224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2525890625}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 43896832.0, 'privatemem': 46153728.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.3214}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42004480.0, 'privatemem': 44298240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.23181875}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 689721344.0, 'privatemem': 2865324032.0, 'nonpaged': 3968784.0, 'virtualmem': 69622706176.0, 'time': 31.0380265625}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 701034496.0, 'privatemem': 2882179072.0, 'nonpaged': 3982704.0, 'virtualmem': 69865975808.0, 'time': 31.334315625}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 685584384.0, 'privatemem': 2856980480.0, 'nonpaged': 3968664.0, 'virtualmem': 69621301248.0, 'time': 33.5692328125}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 697085952.0, 'privatemem': 2868523008.0, 'nonpaged': 3968784.0, 'virtualmem': 69637881856.0, 'time': 30.9457953125}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 690245632.0, 'privatemem': 2862125056.0, 'nonpaged': 3970344.0, 'virtualmem': 69650661376.0, 'time': 33.4727609375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55869440.0, 'privatemem': 58114048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.7086890625}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 56160256.0, 'privatemem': 58540032.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 15.7096078125}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 49836032.0, 'privatemem': 52043776.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2957859375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55492608.0, 'privatemem': 57851904.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.5145359375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 47857664.0, 'privatemem': 50147328.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.8469078125}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 862195712.0, 'privatemem': 3575685120.0, 'nonpaged': 4952784.0, 'virtualmem': 86889738240.0, 'time': 40.3810609375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 865746944.0, 'privatemem': 3578298368.0, 'nonpaged': 4952304.0, 'virtualmem': 86881349632.0, 'time': 36.3784328125}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 869675008.0, 'privatemem': 3581808640.0, 'nonpaged': 4952544.0, 'virtualmem': 86885543936.0, 'time': 38.871209375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 860774400.0, 'privatemem': 3582889984.0, 'nonpaged': 4966464.0, 'virtualmem': 87128813568.0, 'time': 43.21194375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 855191552.0, 'privatemem': 3567927296.0, 'nonpaged': 4952904.0, 'virtualmem': 86877351936.0, 'time': 38.48225625}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57565184.0, 'privatemem': 59461632.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.1426484375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 54370304.0, 'privatemem': 56492032.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.101009375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 62488576.0, 'privatemem': 64598016.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.84624375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57757696.0, 'privatemem': 59613184.0, 'nonpaged': 25640.0, 'virtualmem': 569163776.0, 'time': 15.9433421875}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 67629056.0, 'privatemem': 69304320.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.0379890625}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028907008.0, 'privatemem': 4283650048.0, 'nonpaged': 5936184.0, 'virtualmem': 104104235008.0, 'time': 53.8624046875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037115392.0, 'privatemem': 4290715648.0, 'nonpaged': 5936304.0, 'virtualmem': 104120815616.0, 'time': 53.877346875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037705216.0, 'privatemem': 4291125248.0, 'nonpaged': 5935824.0, 'virtualmem': 104112427008.0, 'time': 54.8691671875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1043337216.0, 'privatemem': 4301135872.0, 'nonpaged': 5935824.0, 'virtualmem': 104111026176.0, 'time': 46.317490625}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028558848.0, 'privatemem': 4282368000.0, 'nonpaged': 5936424.0, 'virtualmem': 104108429312.0, 'time': 53.502359375}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73793536.0, 'privatemem': 75640832.0, 'nonpaged': 26600.0, 'virtualmem': 577552384.0, 'time': 16.6419671875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74006528.0, 'privatemem': 75755520.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 16.59216875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74121216.0, 'privatemem': 75894784.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.6399796875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 75317248.0, 'privatemem': 77017088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.6508421875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73236480.0, 'privatemem': 75030528.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.776903125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1193185280.0, 'privatemem': 4992319488.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 59.2310265625}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186713600.0, 'privatemem': 4982370304.0, 'nonpaged': 6919584.0, 'virtualmem': 121317330944.0, 'time': 62.308228125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1204101120.0, 'privatemem': 5004546048.0, 'nonpaged': 6919704.0, 'virtualmem': 121333911552.0, 'time': 59.4607328125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186025472.0, 'privatemem': 4979195904.0, 'nonpaged': 6919824.0, 'virtualmem': 121321525248.0, 'time': 68.2966625}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1190494208.0, 'privatemem': 4990369792.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 65.9037140625}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 69914624.0, 'privatemem': 71544832.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.5821546875}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 82804736.0, 'privatemem': 84516864.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4147265625}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 80211968.0, 'privatemem': 81952768.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 17.2119453125}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 72941568.0, 'privatemem': 74739712.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.0826671875}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 57122816.0, 'privatemem': 59056128.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 15.8496921875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1363570688.0, 'privatemem': 5696401408.0, 'nonpaged': 7902864.0, 'virtualmem': 138542813184.0, 'time': 77.319371875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1359228928.0, 'privatemem': 5693067264.0, 'nonpaged': 7902504.0, 'virtualmem': 138522038272.0, 'time': 75.611196875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1382010880.0, 'privatemem': 5722746880.0, 'nonpaged': 7903224.0, 'virtualmem': 138563588096.0, 'time': 75.43135625}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1366474752.0, 'privatemem': 5719846912.0, 'nonpaged': 7935264.0, 'virtualmem': 139092529152.0, 'time': 77.2984921875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1380454400.0, 'privatemem': 5713457152.0, 'nonpaged': 7902744.0, 'virtualmem': 138555199488.0, 'time': 72.9519984375}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 82169856.0, 'privatemem': 84209664.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 18.2689421875}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 86765568.0, 'privatemem': 88666112.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 17.703690625}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89808896.0, 'privatemem': 91951104.0, 'nonpaged': 25744.0, 'virtualmem': 562872320.0, 'time': 17.698275}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 83464192.0, 'privatemem': 84893696.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.8156953125}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89182208.0, 'privatemem': 91365376.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 17.637353125}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1688113152.0, 'privatemem': 7102902272.0, 'nonpaged': 9870744.0, 'virtualmem': 172987879424.0, 'time': 109.5945375}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681657856.0, 'privatemem': 7097241600.0, 'nonpaged': 9870264.0, 'virtualmem': 172979490816.0, 'time': 112.0583734375}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1701982208.0, 'privatemem': 7125585920.0, 'nonpaged': 9876984.0, 'virtualmem': 173109383168.0, 'time': 108.868828125}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1696256000.0, 'privatemem': 7110664192.0, 'nonpaged': 9870384.0, 'virtualmem': 172979556352.0, 'time': 100.987990625}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681092608.0, 'privatemem': 7102992384.0, 'nonpaged': 9881424.0, 'virtualmem': 173160042496.0, 'time': 103.1147171875}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 88752128.0, 'privatemem': 90644480.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.194690625}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 91697152.0, 'privatemem': 93396992.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 19.1130046875}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 70430720.0, 'privatemem': 72364032.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 17.7690265625}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 85979136.0, 'privatemem': 87822336.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 19.166028125}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 87728128.0, 'privatemem': 89387008.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.178809375}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2026475520.0, 'privatemem': 8518123520.0, 'nonpaged': 11837784.0, 'virtualmem': 207459684352.0, 'time': 140.7092328125}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2036518912.0, 'privatemem': 8542306304.0, 'nonpaged': 11840544.0, 'virtualmem': 207512752128.0, 'time': 147.6286140625}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2027098112.0, 'privatemem': 8528797696.0, 'nonpaged': 11837424.0, 'virtualmem': 207455424512.0, 'time': 157.0997796875}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2029830144.0, 'privatemem': 8523378688.0, 'nonpaged': 11838144.0, 'virtualmem': 207470809088.0, 'time': 149.35805}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2018607104.0, 'privatemem': 8512258048.0, 'nonpaged': 11837544.0, 'virtualmem': 207443038208.0, 'time': 156.43776875}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 110104576.0, 'privatemem': 112001024.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 19.1979890625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 117399552.0, 'privatemem': 118956032.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.72220625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 102563840.0, 'privatemem': 104300544.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.6945328125}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 105697280.0, 'privatemem': 107380736.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.43420625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 106532864.0, 'privatemem': 108306432.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.3152046875}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2363232256.0, 'privatemem': 9939460096.0, 'nonpaged': 13804464.0, 'virtualmem': 241888612352.0, 'time': 184.053434375}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2365878272.0, 'privatemem': 9953259520.0, 'nonpaged': 13804344.0, 'virtualmem': 241900998656.0, 'time': 192.2616015625}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2358566912.0, 'privatemem': 9937661952.0, 'nonpaged': 13806264.0, 'virtualmem': 241918038016.0, 'time': 189.8282234375}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2342895616.0, 'privatemem': 9925849088.0, 'nonpaged': 13804224.0, 'virtualmem': 241884418048.0, 'time': 182.3936078125}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2347986944.0, 'privatemem': 9933496320.0, 'nonpaged': 13804824.0, 'virtualmem': 241892872192.0, 'time': 186.212921875}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 130637824.0, 'privatemem': 132468736.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 20.00561875}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 115064832.0, 'privatemem': 116396032.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 20.3946609375}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 72556544.0, 'privatemem': 74584064.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 17.1177015625}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 112943104.0, 'privatemem': 114147328.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 20.2790203125}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 129822720.0, 'privatemem': 131096576.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 20.95596875}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2690383872.0, 'privatemem': 11338743808.0, 'nonpaged': 15772944.0, 'virtualmem': 276378443776.0, 'time': 247.372325}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2684055552.0, 'privatemem': 11335376896.0, 'nonpaged': 15771504.0, 'virtualmem': 276344889344.0, 'time': 240.684809375}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2701897728.0, 'privatemem': 11360075776.0, 'nonpaged': 15772344.0, 'virtualmem': 276374052864.0, 'time': 235.606675}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2961162240.0, 'privatemem': 11630002176.0, 'nonpaged': 15773904.0, 'virtualmem': 276618567680.0, 'time': 277.3269875}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2682052608.0, 'privatemem': 11340992512.0, 'nonpaged': 15776304.0, 'virtualmem': 276428775424.0, 'time': 244.7224234375}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 138235904.0, 'privatemem': 139558912.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 21.6494125}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 89427968.0, 'privatemem': 90931200.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4579984375}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 130588672.0, 'privatemem': 131649536.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 21.278078125}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 135176192.0, 'privatemem': 136491008.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 21.5131796875}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 127688704.0, 'privatemem': 129499136.0, 'nonpaged': 26728.0, 'virtualmem': 581746688.0, 'time': 19.93003125}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3732779008.0, 'privatemem': 14553665536.0, 'nonpaged': 19709064.0, 'virtualmem': 345628565504.0, 'time': 353.601725}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3335438336.0, 'privatemem': 14157639680.0, 'nonpaged': 19704744.0, 'virtualmem': 345205465088.0, 'time': 356.084828125}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3416276992.0, 'privatemem': 14252584960.0, 'nonpaged': 19705824.0, 'virtualmem': 345296756736.0, 'time': 364.665215625}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3340185600.0, 'privatemem': 14166282240.0, 'nonpaged': 19705344.0, 'virtualmem': 345218048000.0, 'time': 330.89671875}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3341864960.0, 'privatemem': 14169149440.0, 'nonpaged': 19707504.0, 'virtualmem': 345255796736.0, 'time': 352.603725}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 119099392.0, 'privatemem': 120713216.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 21.3428921875}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139829248.0, 'privatemem': 141701120.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 23.1737}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 151707648.0, 'privatemem': 153325568.0, 'nonpaged': 26488.0, 'virtualmem': 577552384.0, 'time': 22.1648703125}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139603968.0, 'privatemem': 141705216.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 24.3582796875}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 126025728.0, 'privatemem': 128827392.0, 'nonpaged': 27568.0, 'virtualmem': 596426752.0, 'time': 21.027715625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3993194496.0, 'privatemem': 16967299072.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 480.1536890625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3999387648.0, 'privatemem': 16987381760.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 516.035265625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4001804288.0, 'privatemem': 17038946304.0, 'nonpaged': 23718144.0, 'virtualmem': 415501574144.0, 'time': 483.755525}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4013903872.0, 'privatemem': 17002704896.0, 'nonpaged': 23639544.0, 'virtualmem': 414158938112.0, 'time': 503.345384375}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4039008256.0, 'privatemem': 17174925312.0, 'nonpaged': 23918784.0, 'virtualmem': 419020464128.0, 'time': 505.355275}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 164077568.0, 'privatemem': 165376000.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 23.6242703125}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 136712192.0, 'privatemem': 138002432.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.1367515625}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 118976512.0, 'privatemem': 120524800.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 23.2383796875}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 127246336.0, 'privatemem': 128696320.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.4868671875}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 201854976.0, 'privatemem': 202383360.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.734434375}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4636082176.0, 'privatemem': 19810603008.0, 'nonpaged': 27575064.0, 'virtualmem': 483073843200.0, 'time': 602.0996375}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4602040320.0, 'privatemem': 19810873344.0, 'nonpaged': 27579744.0, 'virtualmem': 483141148672.0, 'time': 659.99125625}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4591165440.0, 'privatemem': 19790200832.0, 'nonpaged': 27573024.0, 'virtualmem': 483023708160.0, 'time': 583.1214046875}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4639674368.0, 'privatemem': 19800694784.0, 'nonpaged': 27572544.0, 'virtualmem': 483015319552.0, 'time': 595.6076765625}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4615213056.0, 'privatemem': 19768594432.0, 'nonpaged': 27572304.0, 'virtualmem': 483011125248.0, 'time': 585.95591875}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 122953728.0, 'privatemem': 124391424.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 22.2635234375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 128253952.0, 'privatemem': 129671168.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.54289375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 130244608.0, 'privatemem': 131567616.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 21.3423078125}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 120819712.0, 'privatemem': 121860096.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.1759359375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 197222400.0, 'privatemem': 197992448.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.0388765625}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5291032576.0, 'privatemem': 22605094912.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 769.2572203125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5268750336.0, 'privatemem': 22580580352.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 715.4761953125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5275197440.0, 'privatemem': 22597181440.0, 'nonpaged': 31506504.0, 'virtualmem': 551886561280.0, 'time': 743.6708078125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5559996416.0, 'privatemem': 22927003648.0, 'nonpaged': 31508664.0, 'virtualmem': 552185012224.0, 'time': 777.7286765625}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5265473536.0, 'privatemem': 22609494016.0, 'nonpaged': 31506384.0, 'virtualmem': 551898947584.0, 'time': 774.769990625}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 161509376.0, 'privatemem': 163639296.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 29.432303125}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 152326144.0, 'privatemem': 153423872.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 24.661028125}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 148279296.0, 'privatemem': 150319104.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 25.9785390625}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 153616384.0, 'privatemem': 154677248.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 25.02185}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 154402816.0, 'privatemem': 155430912.0, 'nonpaged': 26360.0, 'virtualmem': 573358080.0, 'time': 25.0472640625}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6044577792.0, 'privatemem': 28556054528.0, 'nonpaged': 39377064.0, 'virtualmem': 690026848256.0, 'time': 238880.438532812}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6581481472.0, 'privatemem': 28245975040.0, 'nonpaged': 39374664.0, 'virtualmem': 689695236096.0, 'time': 1124.5557}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 5939179520.0, 'privatemem': 28300779520.0, 'nonpaged': 39375144.0, 'virtualmem': 689703624704.0, 'time': 61740.7140578125}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597120000.0, 'privatemem': 28281757696.0, 'nonpaged': 39374904.0, 'virtualmem': 689728397312.0, 'time': 1146.400846875}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597758976.0, 'privatemem': 28234469376.0, 'nonpaged': 39375264.0, 'virtualmem': 689703690240.0, 'time': 1061.4835671875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 187748352.0, 'privatemem': 191131648.0, 'nonpaged': 26840.0, 'virtualmem': 581292032.0, 'time': 28.6244015625}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 186040320.0, 'privatemem': 189222912.0, 'nonpaged': 27448.0, 'virtualmem': 593874944.0, 'time': 27.09115625}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 191225856.0, 'privatemem': 192925696.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 27.2597046875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 182910976.0, 'privatemem': 184160256.0, 'nonpaged': 25760.0, 'virtualmem': 562872320.0, 'time': 26.3374671875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 178884608.0, 'privatemem': 179732480.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 26.914534375}} diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 23a4000..f09f0d9 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -4,6 +4,7 @@ // #include "cpprx/rx.hpp" +#include "cpplinq/linq.hpp" #include #include @@ -30,10 +31,135 @@ void PrintPrimes(int n) }); } +std::shared_ptr> Data( + string filename, + rxcpp::Scheduler::shared scheduler = std::make_shared() +); +string extract_value(const string& input, const string& key); + + +void run() +{ + using namespace cpplinq; + + struct item { + string args; + int concurrency; + double time; + + item(const string& input) { + args = extract_value(input, "args"); + concurrency = atoi( extract_value(input, "concurrency").c_str() ); + time = atof( extract_value(input, "time").c_str() ); + } + }; + + cout << "data >input ^parse and >(); + { + std::exception_ptr error; + std::condition_variable cv; + + std::mutex coutLock; + int inID = 0; + int parseID = 0; + int outID = 0; + + auto dataLines = Data( + "data.txt" +// , std::make_shared() + ); + auto input = std::make_shared(); + auto parsing = std::make_shared(); + auto output = std::make_shared(); + auto exp = rxcpp::from(dataLines) + .subscribe_on(input) + .select([&coutLock, &inID](const string& line) { + { + std::unique_lock guard(coutLock); + if (inID++ == 0) std::cout << std::this_thread::get_id(); + std::cout << '>' << std::flush; + } + return line; }) + .observe_on(parsing) + .select([&coutLock, &parseID](const string& line) { + { + std::unique_lock guard(coutLock); + if (parseID++ == 0) std::cout << std::this_thread::get_id(); + std::cout << '^' << std::flush; + } + return item(line); }) + .observe_on(output) +// .delay(std::chrono::milliseconds(10), output) + .subscribe( + [=, &coutLock, &outID](const item& i){ + { + std::unique_lock guard(coutLock); + if (outID++ == 0) std::cout << std::this_thread::get_id(); + std::cout << '<' << std::flush; + } + shared_data_parsed->push_back(i); }, + [&cv](){ + cv.notify_one();}, + [&cv, &error](const std::exception_ptr& e){ + error = e; cv.notify_one();}); + + std::mutex doneLock; + std::unique_lock guard(doneLock); + cv.wait(guard); + if (error != std::exception_ptr()) {std::rethrow_exception(error);} + cout << endl << "data loaded" << endl; + } + + auto data_parsed = shared_data_parsed.get(); + auto data = + from(*data_parsed) + .groupby([](const item& i) { return i.args; }); + + for (auto giter = data.begin(), end = data.end(); giter != end; ++giter) + { + const auto& g = *giter; + + cout << "arguments: " << g.key << endl; + + cout << "concurrency, mean, |, raw_data," << endl; + auto seq = + from(g) + .groupby([](const item& i) { return i.concurrency; }); + + for (auto giter = seq.begin(), end = seq.end(); giter != end; ++giter) + { + const auto& g = *giter; + + cout << g.key << ", "; + + auto times = from(g).select([](const item& i) { return i.time; }); + + auto n = from(g).count(); + auto sum = std::accumulate(times.begin(), times.end(), 0.0); + + cout << (sum / n) << ", |"; + + for (auto timeIter = times.begin(), end = times.end(); + timeIter != end; + ++timeIter) + { + cout << ", " << *timeIter; + } + cout << endl; + } + } +} int main(int argc, char* argv[]) { PrintPrimes(20); + + try { + run(); + } catch (exception& e) { + cerr << "exception: " << e.what() << endl; + } } bool IsPrime(int x) @@ -47,3 +173,77 @@ bool IsPrime(int x) return true; } +regex key_value_pair("'([^\']*)'\\s*[:,]\\s*(\\d+(?:\\.\\d+)?|'[^']*')"); + +string extract_value(const string& input, const string& key) +{ + const std::sregex_iterator end; + for (std::sregex_iterator i(input.cbegin(), input.cend(), key_value_pair); + i != end; + ++i) + { + if ((*i)[1] == key) + { + return (*i)[2]; + } + } + throw std::range_error("search key not found"); +} + +std::shared_ptr> Data( + string filename, + rxcpp::Scheduler::shared scheduler +) +{ + return rxcpp::CreateObservable( + [=](std::shared_ptr> observer) + -> rxcpp::Disposable + { + struct State + { + State(string filename) + : cancel(false), data(filename) { + if (data.fail()) { + throw logic_error("could not find file"); + } + } + bool cancel; + ifstream data; + }; + auto state = std::make_shared(std::move(filename)); + + rxcpp::ComposableDisposable cd; + + cd.Add(rxcpp::Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + rxcpp::fix0([=](rxcpp::Scheduler::shared s, std::function self) -> rxcpp::Disposable + { + try { + if (state->cancel) + return rxcpp::Disposable::Empty(); + + string line; + if (!!getline(state->data, line)) + { + observer->OnNext(std::move(line)); + return s->Schedule(std::move(self)); + } + else + { + observer->OnCompleted(); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + return rxcpp::Disposable::Empty(); + }) + )); + + return cd; + } + ); +} + diff --git a/Rx/CPP/testbench/testbench.vcxproj b/Rx/CPP/testbench/testbench.vcxproj index e357456..3f0ae00 100644 --- a/Rx/CPP/testbench/testbench.vcxproj +++ b/Rx/CPP/testbench/testbench.vcxproj @@ -44,13 +44,13 @@ true - $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\..\..\Ix\CPP\src;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ false - $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\..\..\Ix\CPP\src;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ diff --git a/Rx/CPP/testbench/testbench.vcxproj.filters b/Rx/CPP/testbench/testbench.vcxproj.filters index 2737526..8afd620 100644 --- a/Rx/CPP/testbench/testbench.vcxproj.filters +++ b/Rx/CPP/testbench/testbench.vcxproj.filters @@ -19,12 +19,4 @@ Source Files - - - Header Files - - - Header Files - - \ No newline at end of file -- GitLab From 49764f97b88acc9c255987cdbaebe0e299b65c18 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 2 Mar 2013 22:46:57 -0800 Subject: [PATCH 018/782] added - orderby, foreach, publish and usage thereof --- Rx/CPP/src/cpprx/rx-base.hpp | 13 +- Rx/CPP/src/cpprx/rx-includes.hpp | 38 +++ Rx/CPP/src/cpprx/rx-operators.hpp | 244 +++++++++++++++--- .../{rx-scheduler.h => rx-scheduler.hpp} | 4 +- Rx/CPP/src/cpprx/rx-util.hpp | 4 +- Rx/CPP/src/cpprx/rx-windows.hpp | 3 + Rx/CPP/src/cpprx/rx.hpp | 145 ++++++----- Rx/CPP/testbench/testbench.cpp | 176 ++++++------- 8 files changed, 426 insertions(+), 201 deletions(-) create mode 100644 Rx/CPP/src/cpprx/rx-includes.hpp rename Rx/CPP/src/cpprx/{rx-scheduler.h => rx-scheduler.hpp} (99%) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index cf6642b..e5af503 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_BASE_HPP) #define CPPRX_RX_BASE_HPP -#pragma once namespace rxcpp { @@ -56,7 +58,14 @@ namespace rxcpp virtual ~Observable() {} }; - struct Scheduler : public std::enable_shared_from_this + template + struct GroupedObservable : Observable + { + virtual K Key() = 0; + virtual ~GroupedObservable() {} + }; + + struct Scheduler : public std::enable_shared_from_this { typedef std::chrono::steady_clock clock; typedef std::shared_ptr shared; diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp new file mode 100644 index 0000000..d5be690 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -0,0 +1,38 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(CPPRX_RX_INCLUDES_HPP) +#define CPPRX_RX_INCLUDES_HPP + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rx-util.hpp" +#include "rx-base.hpp" +#include "rx-scheduler.hpp" +#include "rx-windows.hpp" +#include "rx-operators.hpp" + +#pragma pop_macro("min") +#pragma pop_macro("max") + +#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index e4250b1..cfd100d 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_OPERATORS_HPP) #define CPPRX_RX_OPERATORS_HPP -#pragma once namespace rxcpp { @@ -111,17 +113,60 @@ namespace rxcpp return p; } - template - class Subject : - public Observable, - public Observer, - public std::enable_shared_from_this> + + template + class ObservableSubject : + public Base, + public std::enable_shared_from_this { + protected: std::vector>> observers; + + void RemoveObserver(std::shared_ptr> toRemove) + { + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } public: - virtual void OnNext(const T& element) + + virtual Disposable Subscribe(std::shared_ptr> observer) { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d([wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }); + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(std::move(observer)); + return d; + } + }; + + template + class ObserverSubject : + public Base + { + public: + ObserverSubject() {} + + template + explicit ObserverSubject(A&& a) : Base(std::forward(a)) {} + + virtual void OnNext(const T& element) + { + for(auto& o : Base::observers) { try { @@ -137,7 +182,7 @@ namespace rxcpp } virtual void OnCompleted() { - for(auto& o : observers) + for(auto& o : Base::observers) { if (o) { o->OnCompleted(); @@ -147,7 +192,7 @@ namespace rxcpp } virtual void OnError(const std::exception_ptr& error) { - for(auto& o : observers) + for(auto& o : Base::observers) { if (o) { o->OnError(error); @@ -155,36 +200,12 @@ namespace rxcpp } } } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - for(auto& o : observers) - { - if (!o){ - o = std::move(observer); - return d; - } - } - observers.push_back(std::move(observer)); - return d; - } + }; - private: - void RemoveObserver(std::shared_ptr> toRemove) - { - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - *it = nullptr; - } + template + class Subject : + public ObserverSubject, Subject>> + { }; template @@ -193,6 +214,32 @@ namespace rxcpp return std::make_shared>(); } + template + class GroupedObservableSubject : + public Base + { + K key; + public: + GroupedObservableSubject(K key) : key(std::move(key)) {} + + virtual K Key() {return key;} + }; + + template + class GroupedSubject : + public ObserverSubject, GroupedSubject>>> + { + typedef ObserverSubject, GroupedSubject>>> base; + public: + GroupedSubject(K key) : base(std::move(key)) {} + }; + + template + std::shared_ptr> CreateGroupedSubject(K key) + { + return std::make_shared>(std::move(key)); + } + template struct fix0_thunk { F f; @@ -283,6 +330,36 @@ namespace rxcpp return source->Subscribe(observer); } + template + void ForEach( + const std::shared_ptr>& source, + typename util::identity>::type onNext + ) + { + std::mutex lock; + std::condition_variable wake; + bool done = false; + std::exception_ptr error; + auto observer = CreateObserver(std::move(onNext), [&]{ + std::unique_lock guard(lock); + done = true; + wake.notify_one(); + }, [&](const std::exception_ptr& e){ + std::unique_lock guard(lock); + done = true; + error = std::move(e); + wake.notify_one(); + }); + + source->Subscribe(observer); + + { + std::unique_lock guard(lock); + wake.wait(guard, [&]{return done;}); + } + + if (error != std::exception_ptr()) {std::rethrow_exception(error);} + } ////////////////////////////////////////////////////////////////////// // @@ -299,7 +376,7 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) { - return Subscribe( + return Subscribe( source, // on next [=](const T& element) @@ -353,6 +430,95 @@ namespace rxcpp }); } + template + auto GroupBy( + const std::shared_ptr>& source, + KS keySelector, + VS valueSelector, + L less) + -> std::shared_ptr::type, + typename std::decay::type>>>> + { + typedef typename std::decay::type Key; + typedef typename std::decay::type Value; + + typedef std::shared_ptr> LocalGroupObservable; + + return CreateObservable( + [=](std::shared_ptr> observer) + { + typedef std::function OnNext; + typedef std::function OnCompleted; + typedef std::function OnError; + + struct GroupValue + { + OnNext onNext; + OnCompleted onCompleted; + OnError onError; + }; + typedef std::map Groups; + + struct State + { + State(L less) : groups(std::move(less)) {} + std::mutex lock; + Groups groups; + }; + auto state = std::make_shared(std::move(less)); + + return Subscribe( + source, + // on next + [=](const T& element) + { + auto key = keySelector(element); + auto keySubject = CreateGroupedSubject(key); + + typename Groups::iterator groupIt; + bool newGroup = false; + GroupValue value; + value.onNext = [keySubject](Value v){ + keySubject->OnNext(std::move(v));}; + value.onCompleted = [keySubject](){ + keySubject->OnCompleted();}; + value.onError = [keySubject](const std::exception_ptr& e){ + keySubject->OnError(std::move(e));}; + + { + std::unique_lock guard(state->lock); + std::tie(groupIt, newGroup) = state->groups.insert(std::make_pair( + key,std::move(value)) + ); + } + + if (newGroup) + { + LocalGroupObservable nextGroup(std::move(keySubject)); + observer->OnNext(nextGroup); + } + groupIt->second.onNext(valueSelector(element)); + }, + // on completed + [=] + { + for(auto& group : state->groups) { + group.second.onCompleted(); + } + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + for(auto& group : state->groups) { + group.second.onError(error); + } + observer->OnError(error); + }); + }); + } + template std::shared_ptr> Take( const std::shared_ptr>& source, diff --git a/Rx/CPP/src/cpprx/rx-scheduler.h b/Rx/CPP/src/cpprx/rx-scheduler.hpp similarity index 99% rename from Rx/CPP/src/cpprx/rx-scheduler.h rename to Rx/CPP/src/cpprx/rx-scheduler.hpp index c2c16d6..5fcef15 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.h +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_SCHEDULERS_HPP) #define CPPRX_RX_SCHEDULERS_HPP -#pragma once namespace rxcpp { diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 32c4cd0..144fbc6 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_UTIL_HPP) #define CPPRX_RX_UTIL_HPP -#pragma once #if !defined(RXCPP_THREAD_LOCAL) #if defined(_MSC_VER) diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 2c9bac9..72e636f 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -1,5 +1,8 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_WINDOWS_HPP) #define CPPRX_RX_WINDOWS_HPP #pragma once diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index f596bd0..848e945 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -1,110 +1,131 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if !defined(CPPRX_RX_HPP) -#define CPPRX_RX_HPP #pragma once +#include "rx-includes.hpp" -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -#include "rx-util.hpp" -#include "rx-base.hpp" -#include "rx-scheduler.h" -#include "rx-windows.hpp" -#include "rx-operators.hpp" +#if !defined(CPPRX_RX_HPP) +#define CPPRX_RX_HPP namespace rxcpp { - template + template class Binder { Obj obj; + static T defaultValueSelector(T t){return std::move(t);} public: Binder(Obj obj) : obj(std::move(obj)) { } template - auto select(S selector) -> decltype(from(Select(obj, selector))) { - return from(Select(obj, selector)); + auto select(S selector) -> decltype(from(Select(obj, selector))) { + return from(Select(obj, selector)); } template - auto where(P predicate) -> decltype(from(Where(obj, predicate))) { - return from(Where(obj, predicate)); + auto where(P predicate) -> decltype(from(Where(obj, predicate))) { + return from(Where(obj, predicate)); + } + Obj publish() { + return obj; + } + template + auto group_by( + KS keySelector) + -> decltype(from(GroupBy(obj, keySelector, defaultValueSelector, std::less()))) { + return from(GroupBy(obj, keySelector, defaultValueSelector, std::less())); + } + template + auto group_by( + KS keySelector, + VS valueSelector) + -> decltype(from(GroupBy(obj, keySelector, valueSelector, std::less()))) { + return from(GroupBy(obj, keySelector, valueSelector, std::less())); + } + template + auto group_by( + KS keySelector, + VS valueSelector, + L less) + -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { + return from(GroupBy(obj, keySelector, valueSelector, less)); } template - auto take(Integral n) -> decltype(from(Take(obj, n))) { - return from(Take(obj, n)); + auto take(Integral n) -> decltype(from(Take(obj, n))) { + return from(Take(obj, n)); } - auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { - return from(Delay(obj, due)); + auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { + return from(Delay(obj, due)); } - auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { - return from(Delay(obj, due, scheduler)); + auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { + return from(Delay(obj, due, scheduler)); } - auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { - return from(LimitWindow(obj, milliseconds)); + auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { + return from(LimitWindow(obj, milliseconds)); } - auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { - return from(DistinctUntilChanged(obj)); + auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { + return from(DistinctUntilChanged(obj)); } auto subscribe_on(Scheduler::shared scheduler) - -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) + -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) { - return from(SubscribeOnObservable(obj, std::move(scheduler))); + return from(SubscribeOnObservable(obj, std::move(scheduler))); } auto observe_on(Scheduler::shared scheduler) - -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) + -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) { - return from(ObserveOnObserver(obj, std::move(scheduler))); + return from(ObserveOnObserver(obj, std::move(scheduler))); } auto on_dispatcher() - -> decltype(from(ObserveOnDispatcher(obj))) + -> decltype(from(ObserveOnDispatcher(obj))) { - return from(ObserveOnDispatcher(obj)); + return from(ObserveOnDispatcher(obj)); + } + template + void for_each(OnNext onNext) { + ForEach(obj, onNext); } template - auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - auto result = Subscribe(obj, onNext); + auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { + auto result = Subscribe(obj, onNext); return result; } template - auto subscribe(OnNext onNext, OnComplete onComplete) -> decltype(Subscribe(obj, onNext, onComplete)) { - auto result = Subscribe(obj, onNext, onComplete); + auto subscribe(OnNext onNext, OnComplete onComplete) + -> decltype(Subscribe(obj, onNext, onComplete)) { + auto result = Subscribe(obj, onNext, onComplete); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) - -> decltype(Subscribe(obj, onNext, onComplete, onError)) { - auto result = Subscribe(obj, onNext, onComplete, onError); + -> decltype(Subscribe(obj, onNext, onComplete, onError)) { + auto result = Subscribe(obj, onNext, onComplete, onError); return result; } }; - template - Binder::type> from(Obj&& obj) { - return Binder::type>(std::forward(obj)); } -} + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } + + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } -#pragma pop_macro("min") -#pragma pop_macro("max") + template + Binder from(Binder binder) { + return std::move(binder); } + + template + T item(const Binder>>&); + + template + T item(const Binder>>&); + + template + T item(const std::shared_ptr>&); + + template + T item(const std::shared_ptr>&); +} #endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index f09f0d9..01f08c8 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -7,6 +7,7 @@ #include "cpplinq/linq.hpp" #include +#include #include #include #include @@ -37,7 +38,6 @@ std::shared_ptr> Data( ); string extract_value(const string& input, const string& key); - void run() { using namespace cpplinq; @@ -54,101 +54,85 @@ void run() } }; - cout << "data >input ^parse and >(); - { - std::exception_ptr error; - std::condition_variable cv; - - std::mutex coutLock; - int inID = 0; - int parseID = 0; - int outID = 0; - - auto dataLines = Data( - "data.txt" -// , std::make_shared() - ); - auto input = std::make_shared(); - auto parsing = std::make_shared(); - auto output = std::make_shared(); - auto exp = rxcpp::from(dataLines) - .subscribe_on(input) - .select([&coutLock, &inID](const string& line) { - { - std::unique_lock guard(coutLock); - if (inID++ == 0) std::cout << std::this_thread::get_id(); - std::cout << '>' << std::flush; - } - return line; }) - .observe_on(parsing) - .select([&coutLock, &parseID](const string& line) { - { - std::unique_lock guard(coutLock); - if (parseID++ == 0) std::cout << std::this_thread::get_id(); - std::cout << '^' << std::flush; - } - return item(line); }) - .observe_on(output) -// .delay(std::chrono::milliseconds(10), output) - .subscribe( - [=, &coutLock, &outID](const item& i){ - { - std::unique_lock guard(coutLock); - if (outID++ == 0) std::cout << std::this_thread::get_id(); - std::cout << '<' << std::flush; - } - shared_data_parsed->push_back(i); }, - [&cv](){ - cv.notify_one();}, - [&cv, &error](const std::exception_ptr& e){ - error = e; cv.notify_one();}); - - std::mutex doneLock; - std::unique_lock guard(doneLock); - cv.wait(guard); - if (error != std::exception_ptr()) {std::rethrow_exception(error);} - cout << endl << "data loaded" << endl; - } - - auto data_parsed = shared_data_parsed.get(); - auto data = - from(*data_parsed) - .groupby([](const item& i) { return i.args; }); - - for (auto giter = data.begin(), end = data.end(); giter != end; ++giter) - { - const auto& g = *giter; - - cout << "arguments: " << g.key << endl; - - cout << "concurrency, mean, |, raw_data," << endl; - auto seq = - from(g) - .groupby([](const item& i) { return i.concurrency; }); - - for (auto giter = seq.begin(), end = seq.end(); giter != end; ++giter) - { - const auto& g = *giter; - - cout << g.key << ", "; - - auto times = from(g).select([](const item& i) { return i.time; }); - - auto n = from(g).count(); - auto sum = std::accumulate(times.begin(), times.end(), 0.0); - - cout << (sum / n) << ", |"; - - for (auto timeIter = times.begin(), end = times.end(); - timeIter != end; - ++timeIter) - { - cout << ", " << *timeIter; - } - cout << endl; - } - } + auto input = std::make_shared(); + auto output = std::make_shared(); + + auto dataLines = Data("data.txt"); + + int arggroupcount = 0; + + rxcpp::from(dataLines) + .subscribe_on(input) + // parse input into items + .select([](const string& line) { + return item(line);} + ) + // group items by args field + .group_by([](const item& i) { + return i.args;} + ) + .select([=](const std::shared_ptr> & gob){ + return std::make_pair( + gob->Key(), // keep args key + rxcpp::from(gob) + // group items by concurrency field + .group_by([](const item& i){ + return i.concurrency;} + ) + // select only the times field + .select([=] (const std::shared_ptr> & gob){ + return std::make_pair( + gob->Key(), // keep concurrency key + rxcpp::from(gob) + .select([](const item& i){ + return i.time;} + ) + .publish());} + ) + .publish());} + ) + .observe_on(output) + // print the grouped results + // for_each the args to block until the nested subscribes have finished + .for_each([&](const std::pair, std::shared_ptr > > > > >& ob){ + auto argsstate = std::make_shared>(false, ob.first, arggroupcount++); + rxcpp::from(ob.second) + // subscribe the concurrencies within each args + .subscribe([=](const std::pair > >& ob){ + auto linestate = std::make_shared>>(ob.first, std::vector()); + rxcpp::from(ob.second) + // subscribe the times within each concurrency + .subscribe([=](const double& i){ + // collect the times + linestate->second.push_back(i); + },[=]{ + // this concurrency's times are complete + // output a line to the console. + + if (!std::get<0>(*argsstate)) + { + std::get<0>(*argsstate) = true; + cout<<"arguments: "<(*argsstate)<first << ", "; + + auto n = from(linestate->second).count(); + auto sum = std::accumulate(linestate->second.begin(), linestate->second.end(), 0.0); + + cout << (sum / n) << ", |"; + + for (auto timeIter = linestate->second.begin(), end = linestate->second.end(); + timeIter != end; + ++timeIter) + { + cout << ", " << *timeIter; + } + cout << endl; + }); + }); + }); } int main(int argc, char* argv[]) -- GitLab From 1bd7dadd9ba9f1dd344c55b26156810d563d329d Mon Sep 17 00:00:00 2001 From: malayeri Date: Wed, 6 Mar 2013 12:06:02 -0800 Subject: [PATCH 019/782] Merge branch 'master' of https://git01.codeplex.com/forks/martsyn/rx into martsyn/rx -- GitLab From 4a9eb331aca8294a1930d684ffbc3ad0531f2c71 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Feb 2013 14:19:55 -0800 Subject: [PATCH 020/782] publish Rx CPP a little more formally --- Ix/CPP/.gitignore | 7 +++- Rx/CPP/.gitignore | 2 ++ .../MfcTimeFliesLikeAnArrow.vcxproj | 4 +-- Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h | 2 +- .../rxcpp.h => src/cpprx/rx-base.hpp} | 29 ++-------------- .../rxcpp-binder.h => src/cpprx/rx.hpp} | 33 ++++++++++++++++++- Rx/CPP/testbench/testbench.cpp | 2 +- Rx/CPP/testbench/testbench.vcxproj | 6 ++-- 8 files changed, 49 insertions(+), 36 deletions(-) rename Rx/CPP/{testbench/rxcpp.h => src/cpprx/rx-base.hpp} (98%) rename Rx/CPP/{testbench/rxcpp-binder.h => src/cpprx/rx.hpp} (76%) diff --git a/Ix/CPP/.gitignore b/Ix/CPP/.gitignore index 8bbd318..579772e 100644 --- a/Ix/CPP/.gitignore +++ b/Ix/CPP/.gitignore @@ -106,4 +106,9 @@ Generated_Code #added for RIA/Silverlight projects # Visual Studio version. Backup files are not needed, because we have git ;-) _UpgradeReport_Files/ Backup*/ -UpgradeLog*.XML \ No newline at end of file +UpgradeLog*.XML + +# Mac crap +.DS_Store + +a.out diff --git a/Rx/CPP/.gitignore b/Rx/CPP/.gitignore index 5ebd21a..4822a56 100644 --- a/Rx/CPP/.gitignore +++ b/Rx/CPP/.gitignore @@ -161,3 +161,5 @@ pip-log.txt # Mac crap .DS_Store + +a.out diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj index ecef98f..01bf711 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj @@ -46,13 +46,13 @@ true - $(VCInstallDir)include;..\testbench;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\src;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ false - $(VCInstallDir)include;..\testbench;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\src;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h index 8b2f9dd..32ab5ac 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h @@ -60,5 +60,5 @@ #include #include -#include "rxcpp.h" +#include "cpprx/rx.hpp" diff --git a/Rx/CPP/testbench/rxcpp.h b/Rx/CPP/src/cpprx/rx-base.hpp similarity index 98% rename from Rx/CPP/testbench/rxcpp.h rename to Rx/CPP/src/cpprx/rx-base.hpp index 926ae68..3b649a9 100644 --- a/Rx/CPP/testbench/rxcpp.h +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -1,29 +1,9 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if !defined(CPPRX_RX_BASE_HPP) +#define CPPRX_RX_BASE_HPP #pragma once -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max - namespace rxcpp { @@ -883,7 +863,4 @@ namespace rxcpp } } -#include "rxcpp-binder.h" - -#pragma pop_macro("min") -#pragma pop_macro("max") +#endif diff --git a/Rx/CPP/testbench/rxcpp-binder.h b/Rx/CPP/src/cpprx/rx.hpp similarity index 76% rename from Rx/CPP/testbench/rxcpp-binder.h rename to Rx/CPP/src/cpprx/rx.hpp index 0c48e7d..045e4aa 100644 --- a/Rx/CPP/testbench/rxcpp-binder.h +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -1,7 +1,33 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#if !defined(CPPRX_RX_HPP) +#define CPPRX_RX_HPP #pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +#include "rx-base.hpp" + namespace rxcpp { template @@ -45,4 +71,9 @@ namespace rxcpp template Binder from(Obj&& obj) { return Binder(std::move(obj)); } -} \ No newline at end of file +} + +#pragma pop_macro("min") +#pragma pop_macro("max") + +#endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index ce99f97..cd6d162 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -3,7 +3,7 @@ // testbench.cpp : Defines the entry point for the console application. // -#include "rxcpp.h" +#include "cpprx/rx.hpp" #include #include diff --git a/Rx/CPP/testbench/testbench.vcxproj b/Rx/CPP/testbench/testbench.vcxproj index 8512615..e357456 100644 --- a/Rx/CPP/testbench/testbench.vcxproj +++ b/Rx/CPP/testbench/testbench.vcxproj @@ -44,11 +44,13 @@ true + $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ false + $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ @@ -85,10 +87,6 @@ - - - - -- GitLab From dec7a2282678ece0bab4708d05b73d12e0967292 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 09:19:01 -0800 Subject: [PATCH 021/782] get testbench compiling with clang on os.x --- Rx/CPP/src/cpprx/rx-base.hpp | 297 ++++++++++++++++---------------- Rx/CPP/src/cpprx/rx-util.hpp | 18 ++ Rx/CPP/src/cpprx/rx-windows.hpp | 94 ++++++++++ Rx/CPP/src/cpprx/rx.hpp | 48 ++++-- Rx/CPP/testbench/testbench.cpp | 41 +++-- 5 files changed, 325 insertions(+), 173 deletions(-) create mode 100644 Rx/CPP/src/cpprx/rx-util.hpp create mode 100644 Rx/CPP/src/cpprx/rx-windows.hpp diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 3b649a9..29c45ee 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -6,7 +6,6 @@ namespace rxcpp { - ////////////////////////////////////////////////////////////////////// // // Abstract interfaces @@ -218,7 +217,7 @@ namespace rxcpp template Disposable Subscribe( const std::shared_ptr>& source, - typename std::identity>::type onNext, + typename util::identity>::type onNext, std::function onCompleted = nullptr, std::function onError = nullptr ) @@ -228,70 +227,6 @@ namespace rxcpp return source->Subscribe(observer); } - template - struct fix0_thunk { - F f; - fix0_thunk(F&& f) : f(std::move(f)) - { - } - void operator()() const - { - f(*this); - } - }; - template - fix0_thunk fix0(F f) - { - return fix0_thunk(std::move(f)); - } - - template - auto Range( - Integral start, Integral end = (Integral)-1, Integral step = 1 - ) - -> std::shared_ptr> - { - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Integral i; - Integral rem; - }; - auto state = std::make_shared(); - state->cancel = false; - state->i = start; - state->rem = (end - start) / step; - - DefaultScheduler::Instance().Schedule( - fix0([=](std::function self) // TODO: - { - try { - if (state->cancel) - return; - - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - ++state->i; - DefaultScheduler::Instance().Schedule(std::move(self)); - } - } catch (...) { - observer->OnError(std::current_exception()); - } - })); - - return [=]{ state->cancel = true; }; - }); - } - // reference handle type for a container for composing disposables class ComposableDisposable { @@ -427,7 +362,8 @@ namespace rxcpp ) { return CreateObservable( - [=](std::shared_ptr> observer) + [=](std::shared_ptr> observer) + -> Disposable { auto remaining = std::make_shared(n); @@ -499,12 +435,17 @@ namespace rxcpp } ~DefaultScheduler() { - std::unique_lock guard(scheduleLock); - shutdownRequested = true; - guard.unlock(); - cv.notify_one(); + { + std::unique_lock guard(scheduleLock); + shutdownRequested = true; + } + cv.notify_all(); } + + void ScopeEnter() {++trampoline;} + void ScopeExit() {--trampoline; Schedule([]{});} + void Schedule(Work work) { try { @@ -524,9 +465,9 @@ namespace rxcpp { queue.push_back(std::move(work)); } + --trampoline; } - catch (...) - { + catch (...) { --trampoline; throw; } @@ -554,12 +495,14 @@ namespace rxcpp { Clock::time_point dueTime = Clock::now() + std::chrono::duration(milliseconds); - std::unique_lock guard(scheduleLock); - bool wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; + bool wake = false; - scheduledWork.push(std::make_pair(dueTime, std::move(work))); + { + std::unique_lock guard(scheduleLock); + wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; - guard.unlock(); + scheduledWork.push(std::make_pair(dueTime, std::move(work))); + } if (wake) cv.notify_one(); @@ -571,7 +514,6 @@ namespace rxcpp while(!shutdownRequested) { - if (scheduledWork.empty()) { cv.wait(guard); @@ -592,15 +534,83 @@ namespace rxcpp guard.unlock(); try { - work(); + Schedule([=]{work();}); } catch (...) { - // TODO: ??? what now? + // work must catch all expected exceptions + // (yes, expected exceptions is an oxymoron) + std::unexpected(); } guard.lock(); } } }; + template + struct fix0_thunk { + F f; + fix0_thunk(F&& f) : f(std::move(f)) + { + } + void operator()() const + { + f(*this); + } + }; + template + fix0_thunk fix0(F f) + { + return fix0_thunk(std::move(f)); + } + + template + auto Range( + Integral start, Integral end = std::numeric_limits::max(), Integral step = 1 + ) + -> std::shared_ptr> + { + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Integral i; + Integral rem; + }; + auto state = std::make_shared(); + state->cancel = false; + state->i = start; + state->rem = ((end - start) + step) / step; + + DefaultScheduler::Instance().Schedule( + fix0([=](std::function self) // TODO: + { + try { + if (state->cancel) + return; + + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + state->i += step; + DefaultScheduler::Instance().Schedule(std::move(self)); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + })); + + return Disposable([=]{ + state->cancel = true; + }); + }); + } + template std::shared_ptr> Delay( const std::shared_ptr>& source, @@ -616,6 +626,7 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { auto cancel = std::make_shared(false); @@ -667,25 +678,25 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { struct State { - ULONGLONG dueTime; + std::chrono::steady_clock::time_point dueTime; }; auto state = std::make_shared(); - state->dueTime = 0; return Subscribe( source, // on next [=](const T& element) { - auto now = ::GetTickCount64(); + auto now = std::chrono::steady_clock::now(); if (now >= state->dueTime) { observer->OnNext(element); - state->dueTime = now + (ULONGLONG)milliseconds; + state->dueTime = now + std::chrono::duration(milliseconds); } }, // on completed @@ -708,6 +719,7 @@ namespace rxcpp { return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { struct State { T last; bool hasValue; @@ -741,89 +753,86 @@ namespace rxcpp }); } - - - - struct ObserveOnDispatcherOp + class StdQueueDispatcher { - HWND hwnd; + mutable std::queue> pending; + mutable std::condition_variable wake; + mutable std::mutex pendingLock; - ObserveOnDispatcherOp(): hwnd(WindowClass::Instance().CreateWindow_()) + std::function get() const { - if (!hwnd) - throw std::exception("error"); - } - ~ObserveOnDispatcherOp() - { - // send one last message to ourselves to shutdown. - post([=]{ CloseWindow(hwnd); }); + std::function fn; + fn = std::move(pending.front()); + pending.pop(); + return std::move(fn); } - struct WindowClass + void dispatch(std::function fn) const { - static const wchar_t* const className(){ return L"ObserveOnDispatcherOp::WindowClass"; } - WindowClass() + if (fn) { - WNDCLASS wndclass = {}; - wndclass.style = 0; - wndclass.lpfnWndProc = &WndProc; - wndclass.cbClsExtra; - wndclass.cbWndExtra = 0; - wndclass.hInstance = NULL; - wndclass.lpszClassName = className(); - - if (!RegisterClass(&wndclass)) - throw std::exception("error"); - + try { + fn(); + } + catch(...) { + std::unexpected(); + } } - HWND CreateWindow_() + } + + public: + template + void post(Fn fn) const + { { - return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + std::unique_lock guard(pendingLock); + pending.push(std::move(fn)); } - static const int WM_USER_DISPATCH = WM_USER + 1; + wake.notify_one(); + } - static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + void try_dispatch() const + { + std::function fn; { - switch (message) + std::unique_lock guard(pendingLock); + if (!pending.empty()) { - // TODO: shatter attack surface. should validate the message, e.g. using a handle table. - case WM_USER_DISPATCH: - ((void(*)(void*))wParam)((void*)lParam); - return 0; - default: - return DefWindowProc(hwnd, message, wParam, lParam); + fn = get(); } } - static WindowClass& Instance() { - static WindowClass instance; - return instance; - } - }; - - template - void post(Fn fn) const - { - auto p = new Fn(fn); - ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + dispatch(std::move(fn)); } - template - static void run_proc( - void* pvfn - ) + + bool dispatch_one() const { - auto fn = (Fn*)(void*) pvfn; - (*fn)(); - delete fn; + std::function fn; + { + std::unique_lock guard(pendingLock); + wake.wait(guard, [this]{ return !pending.empty();}); + fn = get(); + } + bool result = !!fn; + dispatch(std::move(fn)); + return result; } }; +#if !defined(OBSERVE_ON_DISPATCHER_OP) + typedef StdQueueDispatcher ObserveOnDispatcherOp; +#endif - template + template std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source) + const std::shared_ptr>& source, + std::shared_ptr dispatcher = nullptr) { - auto dispatcher = std::make_shared(); + if (!dispatcher) + { + dispatcher = std::make_shared(); + } return CreateObservable( [=](std::shared_ptr> observer) + -> Disposable { auto cancel = std::make_shared(false); @@ -861,6 +870,6 @@ namespace rxcpp return cd; }); } -} +} #endif diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp new file mode 100644 index 0000000..00148fb --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_UTIL_HPP) +#define CPPRX_RX_UTIL_HPP +#pragma once + +namespace rxcpp { namespace util { + + template + struct identity + { + typedef Type type; + Type operator()(const Type& left) const {return left;} + }; + +}} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp new file mode 100644 index 0000000..b20c645 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -0,0 +1,94 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_WINDOWS_HPP) +#define CPPRX_RX_WINDOWS_HPP +#pragma once + +#if defined(WINDOWS) || defined(WIN32) || defined(_WIN32) + +#define NOMINMAX +#include + +namespace rxcpp +{ + +#define OBSERVE_ON_DISPATCHER_OP + + struct ObserveOnDispatcherOp + { + HWND hwnd; + + ObserveOnDispatcherOp(): hwnd(WindowClass::Instance().CreateWindow_()) + { + if (!hwnd) + throw std::exception("error"); + } + ~ObserveOnDispatcherOp() + { + // send one last message to ourselves to shutdown. + post([=]{ CloseWindow(hwnd); }); + } + + struct WindowClass + { + static const wchar_t* const className(){ return L"ObserveOnDispatcherOp::WindowClass"; } + WindowClass() + { + WNDCLASS wndclass = {}; + wndclass.style = 0; + wndclass.lpfnWndProc = &WndProc; + wndclass.cbClsExtra; + wndclass.cbWndExtra = 0; + wndclass.hInstance = NULL; + wndclass.lpszClassName = className(); + + if (!RegisterClass(&wndclass)) + throw std::exception("error"); + + } + HWND CreateWindow_() + { + return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + } + static const int WM_USER_DISPATCH = WM_USER + 1; + + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + { + switch (message) + { + // TODO: shatter attack surface. should validate the message, e.g. using a handle table. + case WM_USER_DISPATCH: + ((void(*)(void*))wParam)((void*)lParam); + return 0; + default: + return DefWindowProc(hwnd, message, wParam, lParam); + } + } + static WindowClass& Instance() { + static WindowClass instance; + return instance; + } + }; + + template + void post(Fn fn) const + { + auto p = new Fn(fn); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + } + template + static void run_proc( + void* pvfn + ) + { + auto fn = (Fn*)(void*) pvfn; + (*fn)(); + delete fn; + } + }; + +} + +#endif + +#endif diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 045e4aa..ce1864e 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -14,22 +14,19 @@ #include #include #include +#include #include #include #include #include -#include - -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max +#include "rx-util.hpp" +#include "rx-windows.hpp" #include "rx-base.hpp" namespace rxcpp -{ +{ template class Binder { @@ -59,21 +56,44 @@ namespace rxcpp auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } - auto on_dispatcher() -> decltype(from(ObserveOnDispatcher(obj))) + template + auto observe_on(std::shared_ptr dispatcher) + -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) + { + return from(ObserveOnDispatcher(obj, std::move(dispatcher))); + } + auto on_dispatcher(std::shared_ptr dispatcher = nullptr) + -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) { - return from(ObserveOnDispatcher(obj)); + return from(ObserveOnDispatcher(obj, std::move(dispatcher))); } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - return Subscribe(obj, onNext); + DefaultScheduler::Instance().ScopeEnter(); + auto result = Subscribe(obj, onNext); + DefaultScheduler::Instance().ScopeExit(); + return result; + } + template + auto subscribe(OnNext onNext, OnComplete onComplete) -> decltype(Subscribe(obj, onNext, onComplete)) { + DefaultScheduler::Instance().ScopeEnter(); + auto result = Subscribe(obj, onNext, onComplete); + DefaultScheduler::Instance().ScopeExit(); + return result; + } + template + auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) + -> decltype(Subscribe(obj, onNext, onComplete, onError)) { + DefaultScheduler::Instance().ScopeEnter(); + auto result = Subscribe(obj, onNext, onComplete, onError); + DefaultScheduler::Instance().ScopeExit(); + return result; } }; template - Binder from(Obj&& obj) { return Binder(std::move(obj)); } + Binder::type> from(Obj&& obj) { + return Binder::type>(std::move(obj)); } } -#pragma pop_macro("min") -#pragma pop_macro("max") - #endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index cd6d162..1aeb807 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -6,30 +6,41 @@ #include "cpprx/rx.hpp" #include +#include #include +#include +#include +#include using namespace std; bool IsPrime(int x); -int main(int argc, char* argv[]) +void PrintPrimes(int n) { - const int n = 20; - std::cout << "first " << n << " primes squared\n"; - - rxcpp::DefaultScheduler::Instance().Schedule( - [=] - { - auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values) - .where(IsPrime) - .select([](int x) { return std::make_pair(x, x*x); }) - .take(n) - .subscribe( + bool done = false; + auto dispatcher = std::make_shared(); + auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values) + .where(IsPrime) + .select([](int x) { return std::make_pair(x, x*x); }) + .take(n) + .on_dispatcher(dispatcher) + .subscribe( [](pair p) { cout << p.first << " =square=> " << p.second << endl; - }); - }); + }, + [&done](){done = true;}, + [&done](const std::exception_ptr&){done = true;}); + + std::cout << "first " << n << " primes squared" << endl; + while(!done){dispatcher->dispatch_one();} +} + + +int main(int argc, char* argv[]) +{ + PrintPrimes(20); } bool IsPrime(int x) -- GitLab From cf81ed7b7fa6fc4a63b1094aad318584574713e7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 18:52:20 -0800 Subject: [PATCH 022/782] fix windows bugs --- Rx/CPP/src/cpprx/rx-base.hpp | 15 ++++++--------- Rx/CPP/src/cpprx/rx.hpp | 24 +++++++++++++----------- Rx/CPP/testbench/testbench.cpp | 11 ++--------- 3 files changed, 21 insertions(+), 29 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 29c45ee..f677c71 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -818,19 +818,16 @@ namespace rxcpp } }; #if !defined(OBSERVE_ON_DISPATCHER_OP) - typedef StdQueueDispatcher ObserveOnDispatcherOp; + typedef StdQueueDispatcher c; #endif - template + template std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source, - std::shared_ptr dispatcher = nullptr) + const std::shared_ptr>& source) { - if (!dispatcher) - { - dispatcher = std::make_shared(); - } - return CreateObservable( + auto dispatcher = std::make_shared(); + + return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index ce1864e..6d8ffd9 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -4,6 +4,11 @@ #define CPPRX_RX_HPP #pragma once +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + #include #include #include @@ -32,7 +37,7 @@ namespace rxcpp { Obj obj; public: - Binder(Obj&& obj) : obj(std::move(obj)) + Binder(Obj obj) : obj(std::move(obj)) { } template @@ -56,16 +61,10 @@ namespace rxcpp auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } - template - auto observe_on(std::shared_ptr dispatcher) - -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) - { - return from(ObserveOnDispatcher(obj, std::move(dispatcher))); - } - auto on_dispatcher(std::shared_ptr dispatcher = nullptr) - -> decltype(from(ObserveOnDispatcher(obj, std::move(dispatcher)))) + auto on_dispatcher() + -> decltype(from(ObserveOnDispatcher(obj))) { - return from(ObserveOnDispatcher(obj, std::move(dispatcher))); + return from(ObserveOnDispatcher(obj)); } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { @@ -92,8 +91,11 @@ namespace rxcpp }; template Binder::type> from(Obj&& obj) { - return Binder::type>(std::move(obj)); } + return Binder::type>(std::forward(obj)); } } +#pragma pop_macro("min") +#pragma pop_macro("max") + #endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 1aeb807..23a4000 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -18,23 +18,16 @@ bool IsPrime(int x); void PrintPrimes(int n) { - bool done = false; - auto dispatcher = std::make_shared(); + std::cout << "first " << n << " primes squared" << endl; auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers auto s1 = rxcpp::from(values) .where(IsPrime) .select([](int x) { return std::make_pair(x, x*x); }) .take(n) - .on_dispatcher(dispatcher) .subscribe( [](pair p) { cout << p.first << " =square=> " << p.second << endl; - }, - [&done](){done = true;}, - [&done](const std::exception_ptr&){done = true;}); - - std::cout << "first " << n << " primes squared" << endl; - while(!done){dispatcher->dispatch_one();} + }); } -- GitLab From e84e1fbf1acd19fa3dc1e352e4ca920418dee6aa Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 20:55:11 -0800 Subject: [PATCH 023/782] add thread local and unwinder --- Rx/CPP/src/cpprx/rx-util.hpp | 57 ++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 00148fb..d1f69c7 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -4,6 +4,19 @@ #define CPPRX_RX_UTIL_HPP #pragma once +#if !defined(RXCPP_THREAD_LOCAL) +#if defined(_MSC_VER) +#define RXCPP_THREAD_LOCAL __declspec(thread) +#else +#define RXCPP_THREAD_LOCAL __thread +#endif +#endif + +#define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix +#define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) + +#define RXCPP_MAKE_IDENTIFIER(Prefix) RXCPP_CONCAT_EVALUATE(Prefix, __LINE__) + namespace rxcpp { namespace util { template @@ -13,6 +26,50 @@ namespace rxcpp { namespace util { Type operator()(const Type& left) const {return left;} }; + template + class unwinder + { + public: + ~unwinder() + { + if (!!function) + { + try { + (*function)(); + } catch (...) { + std::unexpected(); + } + } + } + + explicit unwinder(Function* functionArg) + : function(functionArg) + { + } + + void dismiss() + { + function = nullptr; + } + + private: + unwinder(); + unwinder(const unwinder&); + unwinder& operator=(const unwinder&); + + Function* function; + }; + }} +#define RXCPP_UNWIND(Name, Function) \ + RXCPP_UNWIND_EXPLICIT(uwfunc_ ## Name, Name, Function) + +#define RXCPP_UNWIND_AUTO(Function) \ + RXCPP_UNWIND_EXPLICIT(RXCPP_MAKE_IDENTIFIER(uwfunc_), RXCPP_MAKE_IDENTIFIER(unwind_), Function) + +#define RXCPP_UNWIND_EXPLICIT(FunctionName, UnwinderName, Function) \ + auto FunctionName = (Function); \ + rxcpp::util::unwinder UnwinderName(std::addressof(FunctionName)) + #endif \ No newline at end of file -- GitLab From 663c6065a3119101d0e5ee929691bdde475f8800 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 21:13:29 -0800 Subject: [PATCH 024/782] changes to Disposable --- Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 2 +- Rx/CPP/src/cpprx/rx-base.hpp | 30 +++++++++++++++++----- 2 files changed, 24 insertions(+), 8 deletions(-) diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp index ed928a0..f86d500 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -76,7 +76,7 @@ void CMainFrame::UserInit() this->UpdateWindow(); }); - composableDisposable.Add(s); + composableDisposable.Add(std::move(s)); } } diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index f677c71..3349a91 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -22,16 +22,32 @@ namespace rxcpp class Disposable { - std::function dispose; + Disposable(); + Disposable(const Disposable&); + typedef std::function dispose_type; + dispose_type dispose; public: - Disposable(std::function dispose) : dispose(std::move(dispose)) - { + explicit Disposable(dispose_type disposearg) + : dispose(std::move(disposearg)) { + disposearg = nullptr;} + Disposable(Disposable&& other) + : dispose(std::move(other.dispose)) { + other.dispose = nullptr; } + Disposable& operator=(Disposable other) { + swap(other); + return *this; } void Dispose() { - if (dispose) dispose(); + if (dispose) { + dispose(); + dispose = nullptr; + } } + void swap(Disposable& rhs) {{using std::swap; swap(dispose, rhs.dispose);}} + static Disposable Empty() { return Disposable(nullptr); } }; + void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} template struct Observable @@ -176,12 +192,12 @@ namespace rxcpp std::weak_ptr> wptr = observer; std::weak_ptr wself = this->shared_from_this(); - Disposable d = [wptr, wself]{ + Disposable d([wptr, wself]{ if (auto self = wself.lock()) { self->RemoveObserver(wptr.lock()); } - }; + }); for(auto& o : observers) { @@ -827,7 +843,7 @@ namespace rxcpp { auto dispatcher = std::make_shared(); - return CreateObservable( + return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { -- GitLab From 7c07b1ad8e998c07ea46e0fb3ec5070c06aabc84 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Feb 2013 21:18:34 -0800 Subject: [PATCH 025/782] add Scheduler and more disposables --- Rx/CPP/src/cpprx/rx-base.hpp | 248 ++++++++++++++++++++++++++--------- 1 file changed, 189 insertions(+), 59 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 3349a91..15584ae 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -56,6 +56,195 @@ namespace rxcpp virtual ~Observable() {} }; + struct Scheduler : public std::enable_shared_from_this + { + typedef std::chrono::steady_clock clock; + typedef std::shared_ptr shared; + typedef std::function Work; + + shared get() {return shared_from_this();} + + virtual ~Scheduler() {} + + virtual clock::time_point Now() =0; + virtual Disposable Schedule(Work work) = 0; + virtual Disposable Schedule(clock::duration due, Work work) = 0; + virtual Disposable Schedule(clock::time_point due, Work work) = 0; + }; + + ////////////////////////////////////////////////////////////////////// + // + // disposables + + + // reference handle type for a container for composing disposables + class ComposableDisposable + { + struct State + { + std::vector disposables; + std::mutex lock; + bool isDisposed; + + State() : isDisposed(false) + { + } + void Add(Disposable&& d) + { + std::unique_lock guard(lock); + if (isDisposed) { + guard.unlock(); + d.Dispose(); + } else { + disposables.emplace_back(std::move(d)); + } + } + void Dispose() + { + std::unique_lock guard(lock); + + if (!isDisposed) + { + isDisposed = true; + auto v = std::move(disposables); + guard.unlock(); + + std::for_each(v.begin(), v.end(), + [](Disposable& d) { + d.Dispose(); }); + } + } + }; + + std::shared_ptr state; + + public: + + ComposableDisposable() : state(new State) + { + } + void Add(Disposable d) const + { + state->Add(std::move(d)); + } + void Dispose() const + { + state->Dispose(); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; + + class ScheduledDisposable + { + struct State : public std::enable_shared_from_this + { + Scheduler::shared scheduler; + Disposable disposable; + + State(Scheduler::shared scheduler, Disposable disposable) + : scheduler(std::move(scheduler)) + , disposable(std::move(disposable)) + { + } + void Dispose() + { + auto local = std::move(scheduler); + if (local) { + auto keepAlive = shared_from_this(); + local->Schedule([keepAlive] (Scheduler::shared) { + keepAlive->disposable.Dispose(); + return Disposable::Empty(); + }); + } + } + }; + + std::shared_ptr state; + + ScheduledDisposable(); + public: + + ScheduledDisposable(Scheduler::shared scheduler, Disposable disposable) + : state(new State(std::move(scheduler), std::move(disposable))) + { + } + void Dispose() const + { + state->Dispose(); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; + + class SharedDisposable + { + typedef std::function dispose_type; + + struct State : public std::enable_shared_from_this + { + mutable Disposable disposable; + mutable std::mutex lock; + + State() : disposable(Disposable::Empty()) {} + + void Set(Disposable disposeArg) const + { + std::unique_lock guard(lock); + {using std::swap; swap(disposable, disposeArg);} + } + void Dispose() + { + std::unique_lock guard(lock); + auto local = std::move(disposable); + guard.unlock(); + local.Dispose(); + } + }; + + std::shared_ptr state; + + public: + + SharedDisposable() + : state(new State()) + { + } + void Dispose() const + { + state->Dispose(); + } + void Set(Disposable disposeArg) const + { + state->Set(std::move(disposeArg)); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; ////////////////////////////////////////////////////////////////////// @@ -243,65 +432,6 @@ namespace rxcpp return source->Subscribe(observer); } - // reference handle type for a container for composing disposables - class ComposableDisposable - { - struct State - { - std::vector disposables; - std::mutex lock; - bool isDisposed; - - State() : isDisposed(false) - { - } - void Add(Disposable&& d) - { - std::unique_lock guard(lock); - if (isDisposed) { - guard.unlock(); - d.Dispose(); - } else { - disposables.push_back(std::move(d)); - } - } - void Dispose() - { - std::unique_lock guard(lock); - - isDisposed = true; - auto v = std::move(disposables); - guard.unlock(); - - std::for_each(v.begin(), v.end(), - [](Disposable& d) { d.Dispose(); }); - } - }; - - std::shared_ptr state; - - public: - ComposableDisposable() : state(new State) - { - } - void Add(Disposable d) const - { - state->Add(std::move(d)); - } - void Dispose() const - { - state->Dispose(); - } - operator Disposable() const - { - auto d = Disposable([=]{ - state->Dispose(); - }); - return d; - } - }; - - ////////////////////////////////////////////////////////////////////// // -- GitLab From cc7340a8dffa18a65fd8b2d1e390691fc87446e9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 1 Mar 2013 10:51:44 -0800 Subject: [PATCH 026/782] add scheduler impl and usage added basic schedulers (Immediate, CurrentThread, EventLoop, NewThread) added subscribe_on and observe_on used these in the test and sample code added WindowScheduler --- Ix/CPP/src/cpplinq/util.hpp | 8 + Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 6 +- Rx/CPP/src/cpprx/rx-base.hpp | 770 +-------------------- Rx/CPP/src/cpprx/rx-operators.hpp | 752 ++++++++++++++++++++ Rx/CPP/src/cpprx/rx-scheduler.h | 395 +++++++++++ Rx/CPP/src/cpprx/rx-util.hpp | 110 ++- Rx/CPP/src/cpprx/rx-windows.hpp | 95 ++- Rx/CPP/src/cpprx/rx.hpp | 27 +- Rx/CPP/testbench/data.txt | 655 ++++++++++++++++++ Rx/CPP/testbench/testbench.cpp | 200 ++++++ Rx/CPP/testbench/testbench.vcxproj | 4 +- Rx/CPP/testbench/testbench.vcxproj.filters | 8 - 12 files changed, 2255 insertions(+), 775 deletions(-) create mode 100644 Rx/CPP/src/cpprx/rx-operators.hpp create mode 100644 Rx/CPP/src/cpprx/rx-scheduler.h create mode 100644 Rx/CPP/testbench/data.txt diff --git a/Ix/CPP/src/cpplinq/util.hpp b/Ix/CPP/src/cpplinq/util.hpp index f1e5222..953a48a 100644 --- a/Ix/CPP/src/cpplinq/util.hpp +++ b/Ix/CPP/src/cpplinq/util.hpp @@ -200,6 +200,14 @@ namespace cpplinq { namespace util { is_set = true; } } + void set(T&& value) { + if (is_set) { + *reinterpret_cast(&storage) = std::move(value); + } else { + new (reinterpret_cast(&storage)) T(std::move(value)); + is_set = true; + } + } T& operator*() { return *get(); } const T& operator*() const { return *get(); } diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp index f86d500..da3d39a 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -48,6 +48,8 @@ CMainFrame::~CMainFrame() // inspired by: http://minirx.codeplex.com/ void CMainFrame::UserInit() { + auto worker = std::make_shared(); + auto mainFormScheduler = std::make_shared(); auto mouseMove = BindEventToObservable(mouseMoveEvent); // set up labels and query @@ -64,8 +66,8 @@ void CMainFrame::UserInit() auto s = rxcpp::from(mouseMove) .select([](MouseMoveEventValue e) { return e.point; }) .distinct_until_changed() - .delay(i * 100 + 1) - .on_dispatcher() + .delay(std::chrono::milliseconds(i * 100 + 1), worker) + .observe_on(mainFormScheduler) .subscribe([=](CPoint point) { label->SetWindowPos(nullptr, point.x+20*i, point.y-20, 20, 30, SWP_NOOWNERZORDER); diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 15584ae..cf6642b 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -47,7 +47,7 @@ namespace rxcpp void swap(Disposable& rhs) {{using std::swap; swap(dispose, rhs.dispose);}} static Disposable Empty() { return Disposable(nullptr); } }; - void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} + inline void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} template struct Observable @@ -246,773 +246,55 @@ namespace rxcpp } }; - - ////////////////////////////////////////////////////////////////////// - // - // constructors - - template - class CreatedObservable : public Observable - { - S subscribe; - - public: - CreatedObservable(S subscribe) : subscribe(std::move(subscribe)) - { - } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - return subscribe(std::move(observer)); - } - }; - - template - std::shared_ptr> CreateObservable(S subscribe) - { - return std::make_shared>(std::move(subscribe)); - } - - template - struct CreatedObserver : public Observer - { - std::function onNext; - std::function onCompleted; - std::function onError; - - virtual void OnNext(const T& element) - { - try - { - if(onNext) - { - onNext(element); - } - } - catch (...) - { - OnError(std::current_exception()); - } - } - virtual void OnCompleted() - { - if(onCompleted) - { - onCompleted(); - clear(); - } - } - virtual void OnError(const std::exception_ptr& error) - { - if(onError) - { - onError(error); - clear(); - } - } - void clear() - { - onNext = nullptr; - onCompleted = nullptr; - onError = nullptr; - } - }; - - template - std::shared_ptr> CreateObserver( - std::function onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) + struct LocalScheduler : public Scheduler { - auto p = std::make_shared>(); - p->onNext = std::move(onNext); - p->onCompleted = std::move(onCompleted); - p->onError = std::move(onError); - - return p; - } - - template - class Subject : - public Observable, - public Observer, - public std::enable_shared_from_this> - { - std::vector>> observers; - public: - virtual void OnNext(const T& element) - { - for(auto& o : observers) - { - try - { - if (o) - o->OnNext(element); - } - catch (...) - { - auto o_ = std::move(o); - o_->OnError(std::current_exception()); - } - } - } - virtual void OnCompleted() - { - for(auto& o : observers) - { - if (o) { - o->OnCompleted(); - o = nullptr; - } - } - } - virtual void OnError(const std::exception_ptr& error) - { - for(auto& o : observers) - { - if (o) { - o->OnError(error); - o = nullptr; - } - } - } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - for(auto& o : observers) - { - if (!o){ - o = std::move(observer); - return d; - } - } - observers.push_back(std::move(observer)); - return d; - } - private: - void RemoveObserver(std::shared_ptr> toRemove) - { - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - *it = nullptr; - } - }; - - template - std::shared_ptr> CreateSubject() - { - return std::make_shared>(); - } - - - ////////////////////////////////////////////////////////////////////// - // - // imperative functions - - template - Disposable Subscribe( - const std::shared_ptr>& source, - typename util::identity>::type onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) - { - auto observer = CreateObserver(std::move(onNext), std::move(onCompleted), std::move(onError)); - - return source->Subscribe(observer); - } - + LocalScheduler(const LocalScheduler&); - ////////////////////////////////////////////////////////////////////// - // - // standard query operators - - template - auto Select( - const std::shared_ptr>& source, - S selector - ) - -> const std::shared_ptr::type>> - { - typedef typename std::result_of::type U; - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - auto result = selector(element); - observer->OnNext(std::move(result)); - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - template - const std::shared_ptr> Where( - const std::shared_ptr>& source, - P predicate - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - auto result = predicate(element); - if (result) - { - observer->OnNext(element); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - template - std::shared_ptr> Take( - const std::shared_ptr>& source, - int n // TODO: long long? - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto remaining = std::make_shared(n); - - ComposableDisposable cd; - - auto d = Subscribe( - source, - // on next - [=](const T& element) - { - if (*remaining) - { - observer->OnNext(element); - if (--*remaining == 0) - { - observer->OnCompleted(); - cd.Dispose(); - } - } - }, - // on completed - [=] - { - if (*remaining) - { - observer->OnCompleted(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - if (*remaining) - { - observer->OnError(error); - } - }); - cd.Add(std::move(d)); - return cd; - }); - } - - - - ////////////////////////////////////////////////////////////////////// - // - // time and schedulers - - struct DefaultScheduler - { - private: DefaultScheduler(const DefaultScheduler&); public: - static DefaultScheduler& Instance() - { - // TODO: leaks. race condition on atexit though. - static DefaultScheduler* instance = new DefaultScheduler; - return *instance; - } - - typedef std::function Work; - - std::atomic trampoline; - - std::vector queue; - - std::thread worker_thread; - DefaultScheduler() : trampoline(0), shutdownRequested(false) - { - worker_thread = std::thread([=]{ worker(); }); - } - ~DefaultScheduler() + static void DoNoThrow(Work& work, Scheduler::shared scheduler) throw() { + if (work) { - std::unique_lock guard(scheduleLock); - shutdownRequested = true; + work(std::move(scheduler)); } - cv.notify_all(); } - - - void ScopeEnter() {++trampoline;} - void ScopeExit() {--trampoline; Schedule([]{});} - - void Schedule(Work work) + static void Do(Work& work, Scheduler::shared scheduler) { try { - if (++trampoline == 1) - { - work(); - - while(!queue.empty()) - { - work = std::move(queue.back()); - queue.pop_back(); - work(); - } - - } - else - { - queue.push_back(std::move(work)); - } - --trampoline; - } - catch (...) { - --trampoline; - throw; - } - } - - struct compare_work - { - template - bool operator()(const T& work1, const T& work2) const { - return work1.first > work2.first; - } - }; - - typedef std::chrono::steady_clock Clock; - - bool shutdownRequested; - std::mutex scheduleLock; - std::condition_variable cv; - std::priority_queue< std::pair, - std::vector>, - compare_work > scheduledWork; - - - void Schedule(int milliseconds, Work work) - { - Clock::time_point dueTime = Clock::now() + std::chrono::duration(milliseconds); - - bool wake = false; - - { - std::unique_lock guard(scheduleLock); - wake = scheduledWork.empty() || dueTime < scheduledWork.top().first; - - scheduledWork.push(std::make_pair(dueTime, std::move(work))); - } - - if (wake) - cv.notify_one(); - } - private: - void worker() - { - std::unique_lock guard(scheduleLock); - - while(!shutdownRequested) - { - if (scheduledWork.empty()) - { - cv.wait(guard); - continue; - } - - auto now = Clock::now(); - auto dueTime = scheduledWork.top().first; - if (dueTime > now) - { - cv.wait_until(guard, dueTime); - continue; - } - - // dispatch work - auto work = std::move(scheduledWork.top().second); - scheduledWork.pop(); - - guard.unlock(); - try { - Schedule([=]{work();}); - } catch (...) { - // work must catch all expected exceptions - // (yes, expected exceptions is an oxymoron) - std::unexpected(); - } - guard.lock(); + DoNoThrow(work, std::move(scheduler)); + } catch (const std::exception& ) { + // work must catch all expected exceptions + std::unexpected(); + } catch (...) { + // work must catch all expected exceptions + std::unexpected(); } } - }; - - template - struct fix0_thunk { - F f; - fix0_thunk(F&& f) : f(std::move(f)) - { - } - void operator()() const - { - f(*this); - } - }; - template - fix0_thunk fix0(F f) - { - return fix0_thunk(std::move(f)); - } - - template - auto Range( - Integral start, Integral end = std::numeric_limits::max(), Integral step = 1 - ) - -> std::shared_ptr> - { - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Integral i; - Integral rem; - }; - auto state = std::make_shared(); - state->cancel = false; - state->i = start; - state->rem = ((end - start) + step) / step; - - DefaultScheduler::Instance().Schedule( - fix0([=](std::function self) // TODO: - { - try { - if (state->cancel) - return; - - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - state->i += step; - DefaultScheduler::Instance().Schedule(std::move(self)); - } - } catch (...) { - observer->OnError(std::current_exception()); - } - })); - return Disposable([=]{ - state->cancel = true; - }); - }); - } - - template - std::shared_ptr> Delay( - const std::shared_ptr>& source, - int milliseconds) - { - // TODO: for some reason, poor interactions take place if - // on_dispatcher() dispatches from UI thread. -#if 0 - if (milliseconds == 0) - return source; -#endif - - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ *cancel = true; })); - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - // TODO: queue - DefaultScheduler::Instance().Schedule( - milliseconds, - [=]{ - if (!*cancel) - observer->OnNext(element); - }); - }, - // on completed - [=] - { - DefaultScheduler::Instance().Schedule( - milliseconds, - [=]{ - if (!*cancel) - observer->OnCompleted(); - }); - }, - // on error - [=](const std::exception_ptr& error) - { - if (!*cancel) - observer->OnError(error); - })); - return cd; - }); - } - - // no more than one event ever 'milliseconds' - // TODO: oops, this is not the right definition for throttle. - template - std::shared_ptr> LimitWindow( - const std::shared_ptr>& source, - int milliseconds) - { - if (milliseconds == 0) - return source; - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - std::chrono::steady_clock::time_point dueTime; - }; - - auto state = std::make_shared(); - - return Subscribe( - source, - // on next - [=](const T& element) - { - auto now = std::chrono::steady_clock::now(); - - if (now >= state->dueTime) - { - observer->OnNext(element); - state->dueTime = now + std::chrono::duration(milliseconds); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 - template - std::shared_ptr> DistinctUntilChanged( - const std::shared_ptr>& source) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - T last; bool hasValue; - }; - - auto state = std::make_shared(); - state->hasValue = false; - - return Subscribe( - source, - // on next - [=](const T& element) - { - if (!state->hasValue || state->last != element) - { - observer->OnNext(element); - state->last = element; - state->hasValue = true; - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - class StdQueueDispatcher - { - mutable std::queue> pending; - mutable std::condition_variable wake; - mutable std::mutex pendingLock; - - std::function get() const + public: + LocalScheduler() { - std::function fn; - fn = std::move(pending.front()); - pending.pop(); - return std::move(fn); } - - void dispatch(std::function fn) const + virtual ~LocalScheduler() { - if (fn) - { - try { - fn(); - } - catch(...) { - std::unexpected(); - } - } } - public: - template - void post(Fn fn) const - { - { - std::unique_lock guard(pendingLock); - pending.push(std::move(fn)); - } - wake.notify_one(); - } + virtual clock::time_point Now() {return clock::now();} - void try_dispatch() const + using Scheduler::Schedule; + virtual Disposable Schedule(Work work) { - std::function fn; - { - std::unique_lock guard(pendingLock); - if (!pending.empty()) - { - fn = get(); - } - } - dispatch(std::move(fn)); + clock::time_point dueTime = clock::now(); + return Schedule(dueTime, std::move(work)); } - - bool dispatch_one() const + + virtual Disposable Schedule(clock::duration due, Work work) { - std::function fn; - { - std::unique_lock guard(pendingLock); - wake.wait(guard, [this]{ return !pending.empty();}); - fn = get(); - } - bool result = !!fn; - dispatch(std::move(fn)); - return result; + clock::time_point dueTime = clock::now() + due; + return Schedule(dueTime, std::move(work)); } }; -#if !defined(OBSERVE_ON_DISPATCHER_OP) - typedef StdQueueDispatcher c; -#endif - - template - std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source) - { - auto dispatcher = std::make_shared(); - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - *cancel = true; - })); - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - dispatcher->post([=]{ - if (!*cancel) - observer->OnNext(element); - }); - }, - // on completed - [=] - { - dispatcher->post([=]{ - if(!*cancel) - observer->OnCompleted(); - }); - }, - // on error - [=](const std::exception_ptr& error) - { - dispatcher->post([=]{ - if (!*cancel) - observer->OnError(error); - }); - })); - return cd; - }); - } } #endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp new file mode 100644 index 0000000..e4250b1 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -0,0 +1,752 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_OPERATORS_HPP) +#define CPPRX_RX_OPERATORS_HPP +#pragma once + +namespace rxcpp +{ + + ////////////////////////////////////////////////////////////////////// + // + // constructors + + template + class CreatedObservable : public Observable + { + S subscribe; + + public: + CreatedObservable(S subscribe) + : subscribe(std::move(subscribe)) + { + } + virtual Disposable Subscribe(std::shared_ptr> observer) + { + if (CurrentThreadScheduler::IsScheduleRequired()) { + auto scheduler = std::make_shared(); + return scheduler->Schedule( + [=](Scheduler::shared){ + try { + return subscribe(observer); + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + } + ); + } + try { + return subscribe(observer); + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + } + }; + + template + std::shared_ptr> CreateObservable(S subscribe) + { + return std::make_shared>(std::move(subscribe)); + } + + template + struct CreatedObserver : public Observer + { + std::function onNext; + std::function onCompleted; + std::function onError; + + virtual void OnNext(const T& element) + { + try + { + if(onNext) + { + onNext(element); + } + } + catch (...) + { + OnError(std::current_exception()); + } + } + virtual void OnCompleted() + { + if(onCompleted) + { + onCompleted(); + clear(); + } + } + virtual void OnError(const std::exception_ptr& error) + { + if(onError) + { + onError(error); + clear(); + } + } + void clear() + { + onNext = nullptr; + onCompleted = nullptr; + onError = nullptr; + } + }; + + template + std::shared_ptr> CreateObserver( + std::function onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto p = std::make_shared>(); + p->onNext = std::move(onNext); + p->onCompleted = std::move(onCompleted); + p->onError = std::move(onError); + + return p; + } + + template + class Subject : + public Observable, + public Observer, + public std::enable_shared_from_this> + { + std::vector>> observers; + public: + virtual void OnNext(const T& element) + { + for(auto& o : observers) + { + try + { + if (o) + o->OnNext(element); + } + catch (...) + { + auto o_ = std::move(o); + o_->OnError(std::current_exception()); + } + } + } + virtual void OnCompleted() + { + for(auto& o : observers) + { + if (o) { + o->OnCompleted(); + o = nullptr; + } + } + } + virtual void OnError(const std::exception_ptr& error) + { + for(auto& o : observers) + { + if (o) { + o->OnError(error); + o = nullptr; + } + } + } + virtual Disposable Subscribe(std::shared_ptr> observer) + { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d([wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }); + + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(std::move(observer)); + return d; + } + + private: + void RemoveObserver(std::shared_ptr> toRemove) + { + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } + }; + + template + std::shared_ptr> CreateSubject() + { + return std::make_shared>(); + } + + template + struct fix0_thunk { + F f; + fix0_thunk(F&& f) : f(std::move(f)) + { + } + Disposable operator()(Scheduler::shared s) const + { + return f(s, *this); + } + }; + template + fix0_thunk fix0(F f) + { + return fix0_thunk(std::move(f)); + } + + template + auto Range( + Integral start, Integral end = std::numeric_limits::max(), Integral step = 1, + Scheduler::shared scheduler = nullptr) + -> std::shared_ptr> + { + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Integral i; + Integral rem; + }; + auto state = std::make_shared(); + state->cancel = false; + state->i = start; + state->rem = ((end - start) + step) / step; + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + try { + if (state->cancel) + return Disposable::Empty(); + + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + state->i += step; + return s->Schedule(std::move(self)); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + }))); + + return cd; + }); + } + + + ////////////////////////////////////////////////////////////////////// + // + // imperative functions + + template + Disposable Subscribe( + const std::shared_ptr>& source, + typename util::identity>::type onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto observer = CreateObserver(std::move(onNext), std::move(onCompleted), std::move(onError)); + + return source->Subscribe(observer); + } + + + ////////////////////////////////////////////////////////////////////// + // + // standard query operators + + template + auto Select( + const std::shared_ptr>& source, + S selector + ) + -> const std::shared_ptr::type>> + { + typedef typename std::result_of::type U; + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + auto result = selector(element); + observer->OnNext(std::move(result)); + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + const std::shared_ptr> Where( + const std::shared_ptr>& source, + P predicate + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + auto result = predicate(element); + if (result) + { + observer->OnNext(element); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + std::shared_ptr> Take( + const std::shared_ptr>& source, + int n // TODO: long long? + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto remaining = std::make_shared(n); + + ComposableDisposable cd; + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (*remaining) + { + observer->OnNext(element); + if (--*remaining == 0) + { + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on completed + [=] + { + if (*remaining) + { + observer->OnCompleted(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + if (*remaining) + { + observer->OnError(error); + } + })); + return cd; + }); + } + + + ////////////////////////////////////////////////////////////////////// + // + // time + + template + std::shared_ptr> Delay( + const std::shared_ptr>& source, + Scheduler::clock::duration due, + Scheduler::shared scheduler = nullptr) + { + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ *cancel = true; })); + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + sd.Set(scheduler->Schedule( + due, + [=] (Scheduler::shared){ + if (!*cancel) + observer->OnNext(element); + return Disposable::Empty(); + } + )); + }, + // on completed + [=] + { + sd.Set(scheduler->Schedule( + due, + [=](Scheduler::shared){ + if (!*cancel) + observer->OnCompleted(); + return Disposable::Empty(); + } + )); + }, + // on error + [=](const std::exception_ptr& error) + { + if (!*cancel) + observer->OnError(error); + })); + return cd; + }); + } + + // no more than one event ever 'milliseconds' + // TODO: oops, this is not the right definition for throttle. + template + std::shared_ptr> LimitWindow( + const std::shared_ptr>& source, + int milliseconds) + { + if (milliseconds == 0) + return source; + + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + std::chrono::steady_clock::time_point dueTime; + }; + + auto state = std::make_shared(); + + return Subscribe( + source, + // on next + [=](const T& element) + { + auto now = std::chrono::steady_clock::now(); + + if (now >= state->dueTime) + { + observer->OnNext(element); + state->dueTime = now + std::chrono::duration(milliseconds); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 + template + std::shared_ptr> DistinctUntilChanged( + const std::shared_ptr>& source) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + T last; bool hasValue; + }; + + auto state = std::make_shared(); + state->hasValue = false; + + return Subscribe( + source, + // on next + [=](const T& element) + { + if (!state->hasValue || state->last != element) + { + observer->OnNext(element); + state->last = element; + state->hasValue = true; + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } + + template + std::shared_ptr> SubscribeOnObservable( + const std::shared_ptr>& source, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + ComposableDisposable cd; + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(scheduler->Schedule([=](Scheduler::shared){ + sd.Set(ScheduledDisposable(scheduler, source->Subscribe(observer))); + return Disposable::Empty(); + })); + return cd; + }); + } + + template + std::shared_ptr> ObserveOnObserver( + const std::shared_ptr>& source, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto queue = std::make_shared(); + auto queueScheduler = queue->GetScheduler(); + + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + queue->Dispose(); + })); + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + sd.Set(queueScheduler->Schedule([=](Scheduler::shared){ + observer->OnNext(element); + return Disposable::Empty(); + })); + queue->RunOnScheduler(scheduler); + }, + // on completed + [=] + { + sd.Set(queueScheduler->Schedule( + [=](Scheduler::shared){ + observer->OnCompleted(); + return Disposable::Empty(); + } + )); + queue->RunOnScheduler(scheduler); + }, + // on error + [=](const std::exception_ptr& error) + { + queueScheduler->Schedule([=](Scheduler::shared){ + observer->OnError(error); + queue->Dispose(); + return Disposable::Empty(); + }); + queue->RunOnScheduler(scheduler); + })); + return cd; + }); + } + + class StdQueueDispatcher + { + mutable std::queue> pending; + mutable std::condition_variable wake; + mutable std::mutex pendingLock; + + std::function get() const + { + std::function fn; + fn = std::move(pending.front()); + pending.pop(); + return std::move(fn); + } + + void dispatch(std::function fn) const + { + if (fn) + { + try { + fn(); + } + catch(...) { + std::unexpected(); + } + } + } + + public: + template + void post(Fn fn) const + { + { + std::unique_lock guard(pendingLock); + pending.push(std::move(fn)); + } + wake.notify_one(); + } + + void try_dispatch() const + { + std::function fn; + { + std::unique_lock guard(pendingLock); + if (!pending.empty()) + { + fn = get(); + } + } + dispatch(std::move(fn)); + } + + bool dispatch_one() const + { + std::function fn; + { + std::unique_lock guard(pendingLock); + wake.wait(guard, [this]{ return !pending.empty();}); + fn = get(); + } + bool result = !!fn; + dispatch(std::move(fn)); + return result; + } + }; +#if defined(OBSERVE_ON_DISPATCHER_OP) + typedef OBSERVE_ON_DISPATCHER_OP ObserveOnDispatcherOp; +#else + typedef StdQueueDispatcher ObserveOnDispatcherOp; +#endif + + template + std::shared_ptr> ObserveOnDispatcher( + const std::shared_ptr>& source) + { + auto dispatcher = std::make_shared(); + + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + *cancel = true; + })); + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + dispatcher->post([=]{ + if (!*cancel) + observer->OnNext(element); + }); + }, + // on completed + [=] + { + dispatcher->post([=]{ + if(!*cancel) + observer->OnCompleted(); + }); + }, + // on error + [=](const std::exception_ptr& error) + { + dispatcher->post([=]{ + if (!*cancel) + observer->OnError(error); + }); + })); + return cd; + }); + } + +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-scheduler.h b/Rx/CPP/src/cpprx/rx-scheduler.h new file mode 100644 index 0000000..c2c16d6 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-scheduler.h @@ -0,0 +1,395 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#if !defined(CPPRX_RX_SCHEDULERS_HPP) +#define CPPRX_RX_SCHEDULERS_HPP +#pragma once + +namespace rxcpp +{ + + ////////////////////////////////////////////////////////////////////// + // + // schedulers + + struct CurrentThreadScheduler : public LocalScheduler + { + private: + CurrentThreadScheduler(const CurrentThreadScheduler&); + + struct compare_work + { + template + bool operator()(const T& work1, const T& work2) const { + return work1.first > work2.first; + } + }; + + typedef std::priority_queue< + std::pair>, + std::vector>>, + compare_work + > ScheduledWork; + + RXCPP_THREAD_LOCAL static ScheduledWork* scheduledWork; + + public: + CurrentThreadScheduler() + { + } + virtual ~CurrentThreadScheduler() + { + } + + static bool IsScheduleRequired() { return scheduledWork == nullptr; } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto cancelable = std::make_shared(std::move(work)); + // check trampoline + if (!!scheduledWork) + { + scheduledWork->push(std::make_pair(dueTime, cancelable)); + return Disposable([=]{(*cancelable.get()) = nullptr;}); + } + + // create and publish new queue + scheduledWork = new ScheduledWork(); + RXCPP_UNWIND_AUTO([]{ + delete scheduledWork; + scheduledWork = nullptr; + }); + + scheduledWork->push(std::make_pair(dueTime, cancelable)); + + // loop until queue is empty + for ( + auto dueTime = scheduledWork->top().first; + std::this_thread::sleep_until(dueTime), true; + dueTime = scheduledWork->top().first + ) + { + // dispatch work + auto work = std::move(*scheduledWork->top().second.get()); + scheduledWork->pop(); + + Do(work, get()); + + if (scheduledWork->empty()) {break;} + } + + return Disposable::Empty(); + } + }; + // static + RXCPP_SELECT_ANY RXCPP_THREAD_LOCAL CurrentThreadScheduler::ScheduledWork* CurrentThreadScheduler::scheduledWork = nullptr; + + struct ImmediateScheduler : public LocalScheduler + { + private: + ImmediateScheduler(const ImmediateScheduler&); + + public: + ImmediateScheduler() + { + } + virtual ~ImmediateScheduler() + { + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto ct = std::make_shared(); + Do(work, ct); + return Disposable::Empty(); + } + }; + + + class WorkQueue : public std::enable_shared_from_this + { + typedef LocalScheduler::Work Work; + typedef LocalScheduler::clock clock; + typedef std::pair Item; + typedef std::shared_ptr shared; + + struct compare_work + { + template + bool operator()(const T& work1, const T& work2) const { + return work1.first > work2.first; + } + }; + + std::atomic trampoline; + std::priority_queue< + std::pair>, + std::vector>>, + compare_work > scheduledWork; + mutable std::mutex lock; + mutable std::condition_variable wake; + mutable std::atomic exit; + + struct WorkQueueScheduler : public LocalScheduler + { + private: + WorkQueueScheduler(); + WorkQueueScheduler(const WorkQueueScheduler&); + + WorkQueue::shared queue; + + public: + WorkQueueScheduler(WorkQueue::shared queue) : queue(queue) + { + } + virtual ~WorkQueueScheduler() + { + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto cancelable = std::make_shared(std::make_pair(get(), std::move(work))); + { + std::unique_lock guard(queue->lock); + queue->scheduledWork.push(std::make_pair(dueTime, cancelable)); + } + queue->wake.notify_one(); + auto local = queue; + return Disposable([local, cancelable]{ + std::unique_lock guard(local->lock); + cancelable.get()->second = nullptr;}); + } + }; + + public: + typedef std::function RunLoop; + typedef std::function Factory; + + WorkQueue() + : trampoline(0) + , exit(false) + { + } + + util::maybe EnsureThread(Factory& factory) + { + util::maybe result; + std::unique_lock guard(lock); + RXCPP_UNWIND(unwindTrampoline, [&]{--trampoline;}); + if (++trampoline == 1) + { + auto local = shared_from_this(); + result.set(factory([local]{local->Run();})); + // trampoline lifetime is now owned by the thread + unwindTrampoline.dismiss(); + } + return result; + } + + void Dispose() const + { + std::unique_lock guard(lock); + if (trampoline > 0) + { + exit = true; + wake.notify_one(); + } + } + operator Disposable() const + { + auto local = shared_from_this(); + return Disposable([local]{ + local->Dispose(); + }); + } + Scheduler::shared GetScheduler() + { + return std::make_shared(shared_from_this()); + } + void Run() + { + auto keepAlive = shared_from_this(); + { + RXCPP_UNWIND_AUTO([&]{--trampoline;}); + + std::unique_lock guard(lock); + + while(!exit && !scheduledWork.empty()) + { + // wait until there is work + wake.wait(guard, [this]{ return this->exit || !this->scheduledWork.empty();}); + if (exit || scheduledWork.empty()) {break;} + + auto item = &scheduledWork.top(); + if (!item->second) {scheduledWork.pop(); continue;} + + // wait until the work is due + while (!exit && item->second && item->second.get()->first->Now() < item->first) + { + wake.wait_until(guard, item->first); + item = &scheduledWork.top(); + } + if (exit || scheduledWork.empty()) {break;} + if (!item->second) {scheduledWork.pop(); continue;} + + // dispatch work + auto work = std::move(item->second.get()->second); + auto scheduler = std::move(item->second.get()->first); + scheduledWork.pop(); + + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + LocalScheduler::Do(work, scheduler); + } + } + exit = false; + } + + Disposable RunOnScheduler(Scheduler::shared scheduler) + { + RXCPP_UNWIND_AUTO([&]{--trampoline;}); + if (++trampoline == 1) + { + // this is decremented when no further work is scheduled + ++trampoline; + auto keepAlive = shared_from_this(); + return scheduler->Schedule( + [keepAlive, scheduler](Scheduler::shared){ + return keepAlive->RunOnSchedulerWork(scheduler);}); + } + return Disposable::Empty(); + } + private: + Disposable RunOnSchedulerWork(Scheduler::shared scheduler) + { + auto keepAlive = shared_from_this(); + + std::unique_lock guard(lock); + + if(!exit && !scheduledWork.empty()) + { + auto& item = scheduledWork.top(); + + // wait until the work is due + if(!exit && item.second.get()->first->Now() < item.first) + { + return scheduler->Schedule( + item.first, + [keepAlive, scheduler](Scheduler::shared){ + return keepAlive->RunOnSchedulerWork(scheduler);}); + } + + if(!exit) + { + // dispatch work + auto work = std::move(item.second.get()->second); + auto scheduler = std::move(item.second.get()->first); + scheduledWork.pop(); + + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + LocalScheduler::Do(work, scheduler); + } + } + + if(!exit && !scheduledWork.empty()) + { + return scheduler->Schedule( + [keepAlive, scheduler](Scheduler::shared){ + return keepAlive->RunOnSchedulerWork(scheduler);}); + } + + // only decrement when no further work is scheduled + --trampoline; + exit = false; + return Disposable::Empty(); + } + }; + + + struct EventLoopScheduler : public LocalScheduler + { + private: + EventLoopScheduler(const EventLoopScheduler&); + + std::shared_ptr queue; + Scheduler::shared scheduler; + std::thread worker; + WorkQueue::Factory factory; + + public: + EventLoopScheduler() + : queue(std::make_shared()) + , scheduler(queue->GetScheduler()) + { + auto local = queue; + factory = [local] (WorkQueue::RunLoop rl) -> std::thread { + return std::thread([local, rl]{rl();}); + }; + } + template + EventLoopScheduler(Factory factoryarg) + : queue(std::make_shared()) + , scheduler(queue->GetScheduler()) + { + auto local = queue; + factory = std::move(factoryarg); + } + virtual ~EventLoopScheduler() + { + if (worker.joinable()) { + worker.detach(); + } + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + Disposable result = scheduler->Schedule(dueTime, std::move(work)); + + auto maybeThread = queue->EnsureThread(factory); + if (maybeThread) + { + if (worker.joinable()) + { + worker.join(); + } + worker = std::move(*maybeThread.get()); + } + return std::move(result); + } + }; + + struct NewThreadScheduler : public LocalScheduler + { + public: + typedef std::function)> Factory; + private: + NewThreadScheduler(const NewThreadScheduler&); + + Factory factory; + public: + + + NewThreadScheduler() : factory([](std::function start){return std::thread(std::move(start));}) + { + } + NewThreadScheduler(Factory factory) : factory(factory) + { + } + virtual ~NewThreadScheduler() + { + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto scheduler = std::make_shared(factory); + return scheduler->Schedule(dueTime, work); + } + }; +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index d1f69c7..32c4cd0 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -12,6 +12,14 @@ #endif #endif +#if !defined(RXCPP_SELECT_ANY) +#if defined(_MSC_VER) +#define RXCPP_SELECT_ANY __declspec(selectany) +#else +#define RXCPP_SELECT_ANY +#endif +#endif + #define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix #define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) @@ -26,7 +34,107 @@ namespace rxcpp { namespace util { Type operator()(const Type& left) const {return left;} }; - template + template + class maybe + { + bool is_set; + typename std::aligned_storage::value>::type + storage; + public: + maybe() + : is_set(false) + { + } + + maybe(T value) + : is_set(false) + { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + + maybe(const maybe& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(*other.get()); + is_set = true; + } + } + maybe(maybe&& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(std::move(*other.get())); + is_set = true; + other.reset(); + } + } + + ~maybe() + { + reset(); + } + + void reset() + { + if (is_set) { + is_set = false; + reinterpret_cast(&storage)->~T(); + } + } + + T* get() { + return is_set ? reinterpret_cast(&storage) : 0; + } + + const T* get() const { + return is_set ? reinterpret_cast(&storage) : 0; + } + + void set(const T& value) { + if (is_set) { + *reinterpret_cast(&storage) = value; + } else { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + } + void set(T&& value) { + if (is_set) { + *reinterpret_cast(&storage) = std::move(value); + } else { + new (reinterpret_cast(&storage)) T(std::move(value)); + is_set = true; + } + } + + T& operator*() { return *get(); } + const T& operator*() const { return *get(); } + T* operator->() { return get(); } + const T* operator->() const { return get(); } + + maybe& operator=(const T& other) { + set(other); + } + maybe& operator=(const maybe& other) { + if (const T* pother = other.get()) { + set(*pother); + } else { + reset(); + } + return *this; + } + + // boolean-like operators + operator T*() { return get(); } + operator const T*() const { return get(); } + + private: + + }; + + template class unwinder { public: diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index b20c645..2c9bac9 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -9,10 +9,12 @@ #define NOMINMAX #include -namespace rxcpp -{ +namespace rxcpp { namespace win32 { + -#define OBSERVE_ON_DISPATCHER_OP +#if !defined(OBSERVE_ON_DISPATCHER_OP) +#define OBSERVE_ON_DISPATCHER_OP rxcpp::win32::ObserveOnDispatcherOp +#endif struct ObserveOnDispatcherOp { @@ -73,21 +75,96 @@ namespace rxcpp template void post(Fn fn) const { - auto p = new Fn(fn); - ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)p); + std::unique_ptr f(new Fn(fn)); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)f.release()); } template static void run_proc( void* pvfn ) { - auto fn = (Fn*)(void*) pvfn; - (*fn)(); - delete fn; + std::unique_ptr f((Fn*)(void*) pvfn); + (*f.get())(); } }; -} + class WindowScheduler : public rxcpp::LocalScheduler + { + HWND hwnd; + Scheduler::shared ct; + typedef std::pair Item; + + struct WindowClass + { + static const wchar_t* const className(){ return L"rxcpp::win32::WindowScheduler::WindowClass"; } + WindowClass() + { + WNDCLASS wndclass = {}; + wndclass.style = 0; + wndclass.lpfnWndProc = &WndProc; + wndclass.cbClsExtra; + wndclass.cbWndExtra = 0; + wndclass.hInstance = NULL; + wndclass.lpszClassName = className(); + + if (!RegisterClass(&wndclass)) + throw std::exception("failed to register windows class"); + + } + HWND CreateWindow_() + { + return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); + } + static const int WM_USER_DISPATCH = WM_USER + 1; + + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + { + switch (message) + { + // TODO: shatter attack surface. should validate the message, e.g. using a handle table. + case WM_USER_DISPATCH: + ((void(*)(void*))wParam)((void*)lParam); + return 0; + default: + return DefWindowProc(hwnd, message, wParam, lParam); + } + } + static WindowClass& Instance() { + static WindowClass instance; + return instance; + } + }; + static void run_proc( + void* pvfn + ) + { + std::unique_ptr f((Item*)(void*) pvfn); + Do(f->second, f->first); + } + + public: + WindowScheduler() + : hwnd(WindowClass::Instance().CreateWindow_()) + , ct(std::make_shared()) + { + if (!hwnd) + throw std::exception("create window failed"); + } + ~WindowScheduler() + { + // send one last message to ourselves to shutdown. + Schedule([=](Scheduler::shared){ CloseWindow(hwnd); return Disposable::Empty();}); + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + std::unique_ptr f(new Item(ct, std::move(work))); + ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)f.release()); + return Disposable::Empty(); + } + }; +} } #endif diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 6d8ffd9..f596bd0 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -27,8 +27,10 @@ #include "rx-util.hpp" -#include "rx-windows.hpp" #include "rx-base.hpp" +#include "rx-scheduler.h" +#include "rx-windows.hpp" +#include "rx-operators.hpp" namespace rxcpp { @@ -52,8 +54,11 @@ namespace rxcpp auto take(Integral n) -> decltype(from(Take(obj, n))) { return from(Take(obj, n)); } - auto delay(int milliseconds) -> decltype(from(Delay(obj, milliseconds))) { - return from(Delay(obj, milliseconds)); + auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { + return from(Delay(obj, due)); + } + auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { + return from(Delay(obj, due, scheduler)); } auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { return from(LimitWindow(obj, milliseconds)); @@ -61,6 +66,16 @@ namespace rxcpp auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } + auto subscribe_on(Scheduler::shared scheduler) + -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) + { + return from(SubscribeOnObservable(obj, std::move(scheduler))); + } + auto observe_on(Scheduler::shared scheduler) + -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) + { + return from(ObserveOnObserver(obj, std::move(scheduler))); + } auto on_dispatcher() -> decltype(from(ObserveOnDispatcher(obj))) { @@ -68,24 +83,18 @@ namespace rxcpp } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - DefaultScheduler::Instance().ScopeEnter(); auto result = Subscribe(obj, onNext); - DefaultScheduler::Instance().ScopeExit(); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete) -> decltype(Subscribe(obj, onNext, onComplete)) { - DefaultScheduler::Instance().ScopeEnter(); auto result = Subscribe(obj, onNext, onComplete); - DefaultScheduler::Instance().ScopeExit(); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) -> decltype(Subscribe(obj, onNext, onComplete, onError)) { - DefaultScheduler::Instance().ScopeEnter(); auto result = Subscribe(obj, onNext, onComplete, onError); - DefaultScheduler::Instance().ScopeExit(); return result; } }; diff --git a/Rx/CPP/testbench/data.txt b/Rx/CPP/testbench/data.txt new file mode 100644 index 0000000..b16aea6 --- /dev/null +++ b/Rx/CPP/testbench/data.txt @@ -0,0 +1,655 @@ +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22437888.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.9785421875}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26136576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.956228125}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22503424.0, 'privatemem': 25968640.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 71.741975}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26177536.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.189240625}} +{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22323200.0, 'privatemem': 25808896.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.7897296875}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14917632.0, 'privatemem': 20385792.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.734965625}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15060992.0, 'privatemem': 20545536.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.028878125}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15052800.0, 'privatemem': 20529152.0, 'nonpaged': 26768.0, 'virtualmem': 577224704.0, 'time': 45.5304375}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14934016.0, 'privatemem': 20406272.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.898271875}} +{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14991360.0, 'privatemem': 20447232.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.425371875}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 32.748084375}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26202112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.5510765625}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22556672.0, 'privatemem': 26021888.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.0404453125}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26038272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 34.0872890625}} +{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25976832.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.026740625}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15093760.0, 'privatemem': 21082112.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 23.0056984375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20918272.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2537171875}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20905984.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2316484375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15192064.0, 'privatemem': 20910080.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.259509375}} +{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 20979712.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.3385359375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25952256.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2717265625}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2175609375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26042368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.07530625}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.281884375}} +{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26185728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.05386875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15245312.0, 'privatemem': 21233664.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.3586671875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15310848.0, 'privatemem': 21250048.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.70775625}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15347712.0, 'privatemem': 21254144.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.6456703125}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 21180416.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.303421875}} +{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15335424.0, 'privatemem': 21299200.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.4817796875}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 25980928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7404328125}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22482944.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2058328125}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22646784.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 17.3264390625}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.233396875}} +{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.4778453125}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15200256.0, 'privatemem': 21196800.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 12.3187859375}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15474688.0, 'privatemem': 21725184.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 11.6904421875}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15384576.0, 'privatemem': 21630976.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.795390625}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15364096.0, 'privatemem': 21606400.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.5224484375}} +{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15343616.0, 'privatemem': 21590016.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.4604203125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22536192.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.291790625}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22753280.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8192703125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25919488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1479078125}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22728704.0, 'privatemem': 26058752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7772765625}} +{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4325453125}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15458304.0, 'privatemem': 21950464.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 11.653565625}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15622144.0, 'privatemem': 22114304.0, 'nonpaged': 28688.0, 'virtualmem': 610779136.0, 'time': 11.60025}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15491072.0, 'privatemem': 21975040.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 15.956359375}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15429632.0, 'privatemem': 21938176.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 16.7639015625}} +{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15560704.0, 'privatemem': 22102016.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 12.432678125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.482378125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22724608.0, 'privatemem': 26005504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.6995578125}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22601728.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7111109375}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22675456.0, 'privatemem': 26017792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.24071875}} +{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22822912.0, 'privatemem': 26206208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1442453125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15446016.0, 'privatemem': 22118400.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.3196953125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15351808.0, 'privatemem': 21860352.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 13.8507890625}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15536128.0, 'privatemem': 22384640.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.411578125}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15728640.0, 'privatemem': 22585344.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.3764765625}} +{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22331392.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.253040625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22650880.0, 'privatemem': 25956352.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1586765625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22700032.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2853515625}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9393859375}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22597632.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.95501875}} +{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22794240.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.9703578125}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15720448.0, 'privatemem': 22822912.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.88916875}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15872000.0, 'privatemem': 22978560.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.7966875}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15642624.0, 'privatemem': 22474752.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.072915625}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15605760.0, 'privatemem': 22548480.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.3262265625}} +{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15503360.0, 'privatemem': 22335488.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.3073703125}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26075136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7767140625}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22683648.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.6023046875}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.590659375}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26128384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.797509375}} +{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26001408.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.114903125}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15843328.0, 'privatemem': 23093248.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.8031640625}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22933504.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.78183125}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15626240.0, 'privatemem': 22466560.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.79186875}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15998976.0, 'privatemem': 23089152.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.6507984375}} +{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15769600.0, 'privatemem': 22892544.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.7464046875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26107904.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5812421875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26030080.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.8055078125}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 23019520.0, 'privatemem': 26374144.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.661046875}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22810624.0, 'privatemem': 26165248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8447890625}} +{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26157056.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7037859375}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15937536.0, 'privatemem': 23482368.0, 'nonpaged': 30384.0, 'virtualmem': 640139264.0, 'time': 9.9560078125}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22953984.0, 'nonpaged': 29888.0, 'virtualmem': 631750656.0, 'time': 9.9779875}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15806464.0, 'privatemem': 23216128.0, 'nonpaged': 30144.0, 'virtualmem': 635944960.0, 'time': 10.0446703125}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15765504.0, 'privatemem': 23171072.0, 'nonpaged': 30128.0, 'virtualmem': 635944960.0, 'time': 9.8954875}} +{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22679552.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.1007609375}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4936453125}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.54201875}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8461453125}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5201171875}} +{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26173440.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.7564125}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16015360.0, 'privatemem': 23687168.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.308821875}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15978496.0, 'privatemem': 23896064.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3545609375}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16105472.0, 'privatemem': 23773184.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.39604375}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16003072.0, 'privatemem': 23670784.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 11.3077953125}} +{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23347200.0, 'nonpaged': 30272.0, 'virtualmem': 640139264.0, 'time': 11.2470921875}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26017792.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.5840734375}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22843392.0, 'privatemem': 26238976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.7056515625}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22765568.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.4621296875}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.7261640625}} +{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22659072.0, 'privatemem': 26132480.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.43949375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24227840.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 10.1509875}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23486464.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.4571375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15953920.0, 'privatemem': 23937024.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.21300625}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16056320.0, 'privatemem': 24068096.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3364984375}} +{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15851520.0, 'privatemem': 23621632.0, 'nonpaged': 30752.0, 'virtualmem': 648527872.0, 'time': 10.205690625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4346625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22941696.0, 'privatemem': 26288128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.588709375}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25997312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.383815625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22818816.0, 'privatemem': 26148864.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.60400625}} +{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22716416.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3768921875}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16101376.0, 'privatemem': 24428544.0, 'nonpaged': 31712.0, 'virtualmem': 665305088.0, 'time': 9.846940625}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16089088.0, 'privatemem': 24199168.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 11.1524609375}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16199680.0, 'privatemem': 24178688.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 9.9980328125}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16023552.0, 'privatemem': 23977984.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 11.2873078125}} +{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24387584.0, 'nonpaged': 31472.0, 'virtualmem': 661110784.0, 'time': 9.934396875}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22781952.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4010015625}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25985024.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2167890625}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26152960.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.4800796875}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26050560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.449178125}} +{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26058752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2931078125}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16310272.0, 'privatemem': 25399296.0, 'nonpaged': 32912.0, 'virtualmem': 686276608.0, 'time': 10.06823125}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16154624.0, 'privatemem': 24883200.0, 'nonpaged': 32432.0, 'virtualmem': 677888000.0, 'time': 10.0306984375}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16171008.0, 'privatemem': 25038848.0, 'nonpaged': 32672.0, 'virtualmem': 682082304.0, 'time': 10.06961875}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16216064.0, 'privatemem': 24817664.0, 'nonpaged': 32192.0, 'virtualmem': 673693696.0, 'time': 10.0746796875}} +{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16375808.0, 'privatemem': 25542656.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 10.037271875}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25985024.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4086859375}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3663890625}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26034176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3019828125}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26144768.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.389559375}} +{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22593536.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2155328125}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16252928.0, 'privatemem': 25710592.0, 'nonpaged': 33632.0, 'virtualmem': 698859520.0, 'time': 9.93735}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16265216.0, 'privatemem': 25427968.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.9944796875}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16236544.0, 'privatemem': 25595904.0, 'nonpaged': 33392.0, 'virtualmem': 694665216.0, 'time': 9.94461875}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16257024.0, 'privatemem': 25403392.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.94913125}} +{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16424960.0, 'privatemem': 26009600.0, 'nonpaged': 33872.0, 'virtualmem': 703053824.0, 'time': 9.9931234375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26169344.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.376209375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22528000.0, 'privatemem': 25866240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2378046875}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26128384.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.225084375}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 26038272.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.23915625}} +{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26140672.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.35693125}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16650240.0, 'privatemem': 26861568.0, 'nonpaged': 34832.0, 'virtualmem': 719831040.0, 'time': 9.7327859375}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16547840.0, 'privatemem': 26378240.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.775103125}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16654336.0, 'privatemem': 26513408.0, 'nonpaged': 34472.0, 'virtualmem': 713539584.0, 'time': 9.8092875}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16445440.0, 'privatemem': 26304512.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.834784375}} +{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16510976.0, 'privatemem': 26243072.0, 'nonpaged': 34112.0, 'virtualmem': 707248128.0, 'time': 9.9615171875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.234246875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26140672.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1942140625}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26079232.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3161734375}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22708224.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2072671875}} +{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2228828125}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16568320.0, 'privatemem': 27033600.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8727921875}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16764928.0, 'privatemem': 27238400.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8168890625}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16842752.0, 'privatemem': 27193344.0, 'nonpaged': 35192.0, 'virtualmem': 726122496.0, 'time': 9.8725515625}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16732160.0, 'privatemem': 27230208.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8796578125}} +{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16576512.0, 'privatemem': 26882048.0, 'nonpaged': 35072.0, 'virtualmem': 724025344.0, 'time': 9.851103125}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22679552.0, 'privatemem': 25993216.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.183775}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1523140625}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2646}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26025984.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.190975}} +{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26173440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.290859375}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17313792.0, 'privatemem': 29270016.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 9.8081125}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17297408.0, 'privatemem': 29560832.0, 'nonpaged': 38672.0, 'virtualmem': 786939904.0, 'time': 9.803896875}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17514496.0, 'privatemem': 29667328.0, 'nonpaged': 38552.0, 'virtualmem': 784842752.0, 'time': 10.44371875}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17350656.0, 'privatemem': 29356032.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 10.5586140625}} +{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17219584.0, 'privatemem': 29265920.0, 'nonpaged': 38072.0, 'virtualmem': 776454144.0, 'time': 11.02230625}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29392896.0, 'privatemem': 32837632.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.5534375}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32817152.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.04296875}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29323264.0, 'privatemem': 32690176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5768078125}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29327360.0, 'privatemem': 32718848.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1712328125}} +{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.193025}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17764352.0, 'privatemem': 30863360.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7636984375}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17707008.0, 'privatemem': 30818304.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7707}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17625088.0, 'privatemem': 30760960.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.812396875}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17649664.0, 'privatemem': 30711808.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 10.313584375}} +{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17674240.0, 'privatemem': 30810112.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.8304125}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1279546875}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1256796875}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29585408.0, 'privatemem': 32956416.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.14424375}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29421568.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1787703125}} +{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29347840.0, 'privatemem': 32718848.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121146875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17829888.0, 'privatemem': 32083968.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7840515625}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17981440.0, 'privatemem': 32190464.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.774884375}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17907712.0, 'privatemem': 32178176.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7712421875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17809408.0, 'privatemem': 32092160.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.883371875}} +{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 18104320.0, 'privatemem': 32366592.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.8319875}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29380608.0, 'privatemem': 32731136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.139365625}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29401088.0, 'privatemem': 32792576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1221734375}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29298688.0, 'privatemem': 32735232.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3343921875}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29564928.0, 'privatemem': 32948224.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.144190625}} +{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32894976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.147003125}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18358272.0, 'privatemem': 34308096.0, 'nonpaged': 45032.0, 'virtualmem': 898088960.0, 'time': 9.80116875}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18325504.0, 'privatemem': 33714176.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.898659375}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18300928.0, 'privatemem': 33689600.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7784}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18210816.0, 'privatemem': 33574912.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.9189640625}} +{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18202624.0, 'privatemem': 33566720.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7934265625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29495296.0, 'privatemem': 32886784.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.111571875}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29429760.0, 'privatemem': 32776192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.199890625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29442048.0, 'privatemem': 32886784.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.11831875}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29597696.0, 'privatemem': 32931840.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1347890625}} +{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32739328.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.171440625}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19292160.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7851578125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19222528.0, 'privatemem': 37990400.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.759603125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19308544.0, 'privatemem': 38092800.0, 'nonpaged': 49928.0, 'virtualmem': 981975040.0, 'time': 9.73698125}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19214336.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7582359375}} +{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19324928.0, 'privatemem': 38129664.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7412640625}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29474816.0, 'privatemem': 32837632.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.169203125}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29614080.0, 'privatemem': 32976896.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1191375}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29626368.0, 'privatemem': 32968704.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1113484375}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 33058816.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.1464140625}} +{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32747520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1111234375}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 20041728.0, 'privatemem': 41103360.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.7898}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19968000.0, 'privatemem': 41009152.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.855309375}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19824640.0, 'privatemem': 40890368.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9260921875}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19947520.0, 'privatemem': 41054208.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9416703125}} +{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19808256.0, 'privatemem': 40882176.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.8916515625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29691904.0, 'privatemem': 33034240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.11079375}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32755712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1449734375}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29315072.0, 'privatemem': 32628736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13280625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1016015625}} +{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32735232.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1100125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20836352.0, 'privatemem': 44212224.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.02668125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20934656.0, 'privatemem': 44322816.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.9877078125}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 21037056.0, 'privatemem': 45981696.0, 'nonpaged': 60152.0, 'virtualmem': 1162330112.0, 'time': 9.9358015625}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20824064.0, 'privatemem': 44150784.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.98304375}} +{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20856832.0, 'privatemem': 44257280.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.009546875}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 33009664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.0923984375}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.163709375}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32849920.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1063703125}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29450240.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0826171875}} +{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29528064.0, 'privatemem': 32833536.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.086065625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21835776.0, 'privatemem': 48500736.0, 'nonpaged': 63032.0, 'virtualmem': 1212661760.0, 'time': 10.0842015625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21663744.0, 'privatemem': 47255552.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.0181609375}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21577728.0, 'privatemem': 47198208.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.846165625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21389312.0, 'privatemem': 46759936.0, 'nonpaged': 61112.0, 'virtualmem': 1179107328.0, 'time': 11.5423390625}} +{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21254144.0, 'privatemem': 46899200.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 11.306240625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.85168125}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 33005568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.58709375}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32862208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5917140625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32821248.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1530390625}} +{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29405184.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08974375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23420928.0, 'privatemem': 55808000.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2232734375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23494656.0, 'privatemem': 55554048.0, 'nonpaged': 72392.0, 'virtualmem': 1376239616.0, 'time': 10.3183484375}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23584768.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.3544203125}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23617536.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2523703125}} +{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23609344.0, 'privatemem': 55885824.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.154103125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29544448.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0866078125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29507584.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0993953125}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32841728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.10189375}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.0977}} +{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29581312.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0975171875}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24719360.0, 'privatemem': 61693952.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.415759375}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24862720.0, 'privatemem': 61919232.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2971765625}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24784896.0, 'privatemem': 61628416.0, 'nonpaged': 80552.0, 'virtualmem': 1518845952.0, 'time': 10.34406875}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24969216.0, 'privatemem': 61984768.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2925640625}} +{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24752128.0, 'privatemem': 61415424.0, 'nonpaged': 80312.0, 'virtualmem': 1514651648.0, 'time': 10.284221875}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29650944.0, 'privatemem': 33046528.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.15705625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29700096.0, 'privatemem': 33017856.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.122590625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29659136.0, 'privatemem': 33026048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08970625}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32915456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1275171875}} +{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32882688.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.14285}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26378240.0, 'privatemem': 67780608.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.4648703125}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26124288.0, 'privatemem': 67293184.0, 'nonpaged': 88112.0, 'virtualmem': 1653063680.0, 'time': 10.5292671875}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26046464.0, 'privatemem': 67276800.0, 'nonpaged': 87992.0, 'virtualmem': 1648869376.0, 'time': 10.491190625}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26034176.0, 'privatemem': 67489792.0, 'nonpaged': 88232.0, 'virtualmem': 1653063680.0, 'time': 10.5243890625}} +{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26234880.0, 'privatemem': 67649536.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.5925109375}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32944128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.150478125}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29741056.0, 'privatemem': 33099776.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1190796875}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 33005568.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.178025}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32948224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1318578125}} +{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29933568.0, 'privatemem': 33325056.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 13.130896875}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27303936.0, 'privatemem': 73404416.0, 'nonpaged': 96272.0, 'virtualmem': 1795670016.0, 'time': 10.5394765625}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27607040.0, 'privatemem': 73625600.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.565934375}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27287552.0, 'privatemem': 72835072.0, 'nonpaged': 95552.0, 'virtualmem': 1783087104.0, 'time': 10.6236890625}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27480064.0, 'privatemem': 73379840.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.57548125}} +{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27201536.0, 'privatemem': 73240576.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.68160625}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29671424.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.175703125}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29827072.0, 'privatemem': 33165312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1375234375}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29777920.0, 'privatemem': 33116160.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121140625}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 32870400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1075078125}} +{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29704192.0, 'privatemem': 33001472.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.150696875}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29577216.0, 'privatemem': 84500480.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.8671703125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29835264.0, 'privatemem': 84918272.0, 'nonpaged': 111392.0, 'virtualmem': 2059911168.0, 'time': 10.893078125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29667328.0, 'privatemem': 84197376.0, 'nonpaged': 110672.0, 'virtualmem': 2047328256.0, 'time': 10.899709375}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29663232.0, 'privatemem': 84520960.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.9027828125}} +{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 84615168.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.904421875}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 32960512.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.132984375}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29839360.0, 'privatemem': 33132544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13160625}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29978624.0, 'privatemem': 33378304.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.1281796875}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33095680.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1194140625}} +{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29880320.0, 'privatemem': 33148928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.140121875}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32329728.0, 'privatemem': 96473088.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.03265625}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32165888.0, 'privatemem': 96047104.0, 'nonpaged': 126272.0, 'virtualmem': 2319958016.0, 'time': 11.1066328125}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32178176.0, 'privatemem': 96284672.0, 'nonpaged': 126512.0, 'virtualmem': 2324152320.0, 'time': 11.0177765625}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32161792.0, 'privatemem': 96284672.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.15135}} +{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32096256.0, 'privatemem': 96309248.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.1041015625}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33148928.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.127125}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29913088.0, 'privatemem': 33284096.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1395265625}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29921280.0, 'privatemem': 33263616.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.136646875}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29761536.0, 'privatemem': 33140736.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1379828125}} +{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29818880.0, 'privatemem': 33173504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.7975015625}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34549760.0, 'privatemem': 107462656.0, 'nonpaged': 141632.0, 'virtualmem': 2588393472.0, 'time': 12.9889609375}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34643968.0, 'privatemem': 108085248.0, 'nonpaged': 142352.0, 'virtualmem': 2600976384.0, 'time': 13.0880796875}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34697216.0, 'privatemem': 107810816.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 13.2690765625}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34508800.0, 'privatemem': 107683840.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 12.4901671875}} +{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34443264.0, 'privatemem': 107638784.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 11.23786875}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29847552.0, 'privatemem': 33222656.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.127740625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29859840.0, 'privatemem': 33206272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22630625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29896704.0, 'privatemem': 33259520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1849640625}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29884416.0, 'privatemem': 33206272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.13985}} +{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33333248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1424328125}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37142528.0, 'privatemem': 119185408.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.397996875}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37056512.0, 'privatemem': 119328768.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.38355}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37068800.0, 'privatemem': 119164928.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.4034015625}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37187584.0, 'privatemem': 119382016.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.341525}} +{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37076992.0, 'privatemem': 119296000.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.373334375}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30105600.0, 'privatemem': 33378304.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.18291875}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30064640.0, 'privatemem': 33406976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.201753125}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30154752.0, 'privatemem': 33447936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1939015625}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30044160.0, 'privatemem': 33349632.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2285859375}} +{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30068736.0, 'privatemem': 33341440.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1834984375}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47366144.0, 'privatemem': 141705216.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.7742625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47321088.0, 'privatemem': 141434880.0, 'nonpaged': 187712.0, 'virtualmem': 3393699840.0, 'time': 11.8519890625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47198208.0, 'privatemem': 141729792.0, 'nonpaged': 188432.0, 'virtualmem': 3406282752.0, 'time': 11.8748625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47349760.0, 'privatemem': 141578240.0, 'nonpaged': 187952.0, 'virtualmem': 3397894144.0, 'time': 11.80855625}} +{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47333376.0, 'privatemem': 141635584.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.8793171875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30441472.0, 'privatemem': 33677312.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1907140625}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30380032.0, 'privatemem': 33607680.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.224996875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30326784.0, 'privatemem': 33628160.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1955234375}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30355456.0, 'privatemem': 33726464.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 13.1947671875}} +{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30322688.0, 'privatemem': 33738752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2064796875}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52543488.0, 'privatemem': 163958784.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 11.974178125}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52502528.0, 'privatemem': 164315136.0, 'nonpaged': 219512.0, 'virtualmem': 3955736576.0, 'time': 11.9167046875}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52707328.0, 'privatemem': 164122624.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.118128125}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52293632.0, 'privatemem': 163651584.0, 'nonpaged': 218792.0, 'virtualmem': 3943153664.0, 'time': 12.049109375}} +{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52748288.0, 'privatemem': 163999744.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.0723515625}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30642176.0, 'privatemem': 33882112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1681703125}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30302208.0, 'privatemem': 33697792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1825015625}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30408704.0, 'privatemem': 33726464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2253203125}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30486528.0, 'privatemem': 33800192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.250696875}} +{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30560256.0, 'privatemem': 33894400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.174471875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58105856.0, 'privatemem': 186347520.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.09041875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57851904.0, 'privatemem': 186142720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9983140625}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57663488.0, 'privatemem': 185761792.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.26386875}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57929728.0, 'privatemem': 186257408.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9970984375}} +{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58085376.0, 'privatemem': 186654720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 12.0862875}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30867456.0, 'privatemem': 34107392.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2160328125}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30945280.0, 'privatemem': 34258944.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.2101375}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31059968.0, 'privatemem': 34291712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3171546875}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31064064.0, 'privatemem': 34279424.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2282890625}} +{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31006720.0, 'privatemem': 34263040.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.209078125}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63021056.0, 'privatemem': 208171008.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 13.048375}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63369216.0, 'privatemem': 208424960.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.2770109375}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63447040.0, 'privatemem': 208539648.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.228196875}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63488000.0, 'privatemem': 208715776.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.670853125}} +{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63070208.0, 'privatemem': 208207872.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.4422}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31617024.0, 'privatemem': 34848768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2811921875}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31719424.0, 'privatemem': 34897920.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22355625}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31494144.0, 'privatemem': 34746368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22349375}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31694848.0, 'privatemem': 34947072.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2325609375}} +{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31547392.0, 'privatemem': 34807808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.767953125}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 73158656.0, 'privatemem': 252420096.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 15.0598109375}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 65974272.0, 'privatemem': 252903424.0, 'nonpaged': 342152.0, 'virtualmem': 6099025920.0, 'time': 13.8913953125}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66895872.0, 'privatemem': 253501440.0, 'nonpaged': 342632.0, 'virtualmem': 6107414528.0, 'time': 13.2943546875}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 67772416.0, 'privatemem': 252964864.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.7788609375}} +{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66498560.0, 'privatemem': 252874752.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.8031625}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24178688.0, 'privatemem': 27402240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.357275}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23916544.0, 'privatemem': 27070464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3384296875}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24154112.0, 'privatemem': 27303936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3860484375}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24080384.0, 'privatemem': 27303936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.40868125}} +{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23764992.0, 'privatemem': 26914816.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3454890625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74870784.0, 'privatemem': 296960000.0, 'nonpaged': 403512.0, 'virtualmem': 7172767744.0, 'time': 13.6358265625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 84811776.0, 'privatemem': 298262528.0, 'nonpaged': 403832.0, 'virtualmem': 7176962048.0, 'time': 14.18599375}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75407360.0, 'privatemem': 296779776.0, 'nonpaged': 403592.0, 'virtualmem': 7172767744.0, 'time': 13.6721390625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75026432.0, 'privatemem': 296505344.0, 'nonpaged': 403112.0, 'virtualmem': 7164379136.0, 'time': 13.3102890625}} +{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74461184.0, 'privatemem': 296538112.0, 'nonpaged': 403272.0, 'virtualmem': 7168573440.0, 'time': 14.0042234375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24694784.0, 'privatemem': 27824128.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3436484375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24739840.0, 'privatemem': 27815936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3563359375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24772608.0, 'privatemem': 27918336.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4315375}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24756224.0, 'privatemem': 27865088.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.345803125}} +{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24608768.0, 'privatemem': 27750400.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.402634375}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95748096.0, 'privatemem': 343252992.0, 'nonpaged': 465312.0, 'virtualmem': 8267284480.0, 'time': 14.8233890625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 96260096.0, 'privatemem': 343367680.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.9048890625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95764480.0, 'privatemem': 342867968.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.65851875}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95637504.0, 'privatemem': 342515712.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.7174265625}} +{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95924224.0, 'privatemem': 342884352.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.8882921875}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25047040.0, 'privatemem': 28094464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3807953125}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24981504.0, 'privatemem': 28151808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.398909375}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25075712.0, 'privatemem': 28147712.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.359221875}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25006080.0, 'privatemem': 28098560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3784}} +{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24997888.0, 'privatemem': 28069888.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3560390625}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 105529344.0, 'privatemem': 386404352.0, 'nonpaged': 526512.0, 'virtualmem': 9336832000.0, 'time': 15.17243125}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106209280.0, 'privatemem': 387317760.0, 'nonpaged': 526992.0, 'virtualmem': 9345220608.0, 'time': 15.41375625}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 107094016.0, 'privatemem': 388059136.0, 'nonpaged': 526752.0, 'virtualmem': 9341026304.0, 'time': 15.4270546875}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106483712.0, 'privatemem': 387428352.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.0365046875}} +{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106057728.0, 'privatemem': 386617344.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.11465}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28733440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4772109375}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29986816.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.39680625}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33005568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.43141875}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28782592.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4375484375}} +{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29941760.0, 'privatemem': 33050624.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 13.40918125}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 124895232.0, 'privatemem': 473268224.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.8352921875}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125243392.0, 'privatemem': 474202112.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.9860609375}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 126054400.0, 'privatemem': 474787840.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.8798015625}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125100032.0, 'privatemem': 473649152.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.90209375}} +{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 127406080.0, 'privatemem': 482037760.0, 'nonpaged': 658512.0, 'virtualmem': 11643699200.0, 'time': 16.0772640625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30760960.0, 'privatemem': 33771520.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.4638640625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30720000.0, 'privatemem': 33730560.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4992015625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30593024.0, 'privatemem': 33632256.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.460190625}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30691328.0, 'privatemem': 33710080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.584534375}} +{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30756864.0, 'privatemem': 33738752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.8325828125}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145821696.0, 'privatemem': 562421760.0, 'nonpaged': 772032.0, 'virtualmem': 13627604992.0, 'time': 18.0121359375}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145391616.0, 'privatemem': 562782208.0, 'nonpaged': 772416.0, 'virtualmem': 13635993600.0, 'time': 16.273371875}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145211392.0, 'privatemem': 561577984.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.684478125}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145367040.0, 'privatemem': 561598464.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.70395}} +{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145969152.0, 'privatemem': 562495488.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.7380234375}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31399936.0, 'privatemem': 34484224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5152703125}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31645696.0, 'privatemem': 34541568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5179421875}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31395840.0, 'privatemem': 34435072.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.486846875}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34500608.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5053265625}} +{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31473664.0, 'privatemem': 34447360.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.506196875}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166944768.0, 'privatemem': 650125312.0, 'nonpaged': 895176.0, 'virtualmem': 15795929088.0, 'time': 17.12616875}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166453248.0, 'privatemem': 650084352.0, 'nonpaged': 895656.0, 'virtualmem': 15804317696.0, 'time': 17.1012453125}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166957056.0, 'privatemem': 650522624.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.041084375}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166461440.0, 'privatemem': 651186176.0, 'nonpaged': 896136.0, 'virtualmem': 15812706304.0, 'time': 17.265559375}} +{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166281216.0, 'privatemem': 650743808.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.20788125}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33193984.0, 'privatemem': 36044800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.543359375}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33120256.0, 'privatemem': 35979264.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5913015625}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35794944.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5597421875}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35885056.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.561975}} +{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33013760.0, 'privatemem': 35872768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.552240625}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188612608.0, 'privatemem': 740990976.0, 'nonpaged': 1019232.0, 'virtualmem': 17964384256.0, 'time': 18.23205}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190369792.0, 'privatemem': 742092800.0, 'nonpaged': 1018176.0, 'virtualmem': 17947607040.0, 'time': 18.1267921875}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190291968.0, 'privatemem': 751833088.0, 'nonpaged': 1034976.0, 'virtualmem': 18241208320.0, 'time': 18.278765625}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 187871232.0, 'privatemem': 739778560.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 18.356121875}} +{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188469248.0, 'privatemem': 739135488.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 17.9174328125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34922496.0, 'privatemem': 37539840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.705434375}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37617664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.677278125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37523456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.64224375}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35012608.0, 'privatemem': 37642240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.65468125}} +{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35115008.0, 'privatemem': 37711872.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.70276875}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228339712.0, 'privatemem': 915566592.0, 'nonpaged': 1264176.0, 'virtualmem': 22246768640.0, 'time': 19.006409375}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 229093376.0, 'privatemem': 916045824.0, 'nonpaged': 1264296.0, 'virtualmem': 22263349248.0, 'time': 19.33424375}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228802560.0, 'privatemem': 915972096.0, 'nonpaged': 1264184.0, 'virtualmem': 22263349248.0, 'time': 19.201040625}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228282368.0, 'privatemem': 915853312.0, 'nonpaged': 1263936.0, 'virtualmem': 22242574336.0, 'time': 19.1797125}} +{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 227971072.0, 'privatemem': 915865600.0, 'nonpaged': 1264896.0, 'virtualmem': 22259351552.0, 'time': 20.5840234375}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36610048.0, 'privatemem': 39178240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2996234375}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36446208.0, 'privatemem': 39006208.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2134390625}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36413440.0, 'privatemem': 39055360.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.35226875}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36429824.0, 'privatemem': 39075840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8014796875}} +{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36474880.0, 'privatemem': 39116800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7755546875}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 267964416.0, 'privatemem': 1090080768.0, 'nonpaged': 1509464.0, 'virtualmem': 26549927936.0, 'time': 19.5823140625}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 268500992.0, 'privatemem': 1091354624.0, 'nonpaged': 1509816.0, 'virtualmem': 26554122240.0, 'time': 19.5744}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269398016.0, 'privatemem': 1090744320.0, 'nonpaged': 1509576.0, 'virtualmem': 26549927936.0, 'time': 19.7508015625}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269123584.0, 'privatemem': 1093181440.0, 'nonpaged': 1514664.0, 'virtualmem': 26642202624.0, 'time': 19.75071875}} +{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269733888.0, 'privatemem': 1091674112.0, 'nonpaged': 1511384.0, 'virtualmem': 26583482368.0, 'time': 19.5216640625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36532224.0, 'privatemem': 39153664.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.9015625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36720640.0, 'privatemem': 39264256.0, 'nonpaged': 25864.0, 'virtualmem': 564969472.0, 'time': 13.90245}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31596544.0, 'privatemem': 34111488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8932265625}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34131968.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.9260484375}} +{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34066432.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.954315625}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 315875328.0, 'privatemem': 1271836672.0, 'nonpaged': 1755264.0, 'virtualmem': 30861475840.0, 'time': 19.696196875}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 312127488.0, 'privatemem': 1268944896.0, 'nonpaged': 1755944.0, 'virtualmem': 30869929984.0, 'time': 19.7884125}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313524224.0, 'privatemem': 1270001664.0, 'nonpaged': 1755344.0, 'virtualmem': 30861475840.0, 'time': 19.5355734375}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313815040.0, 'privatemem': 1271222272.0, 'nonpaged': 1756064.0, 'virtualmem': 30874058752.0, 'time': 19.61661875}} +{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 314990592.0, 'privatemem': 1271472128.0, 'nonpaged': 1755624.0, 'virtualmem': 30865735680.0, 'time': 20.050821875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38105088.0, 'privatemem': 40636416.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.0955625}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37982208.0, 'privatemem': 40583168.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.040196875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38129664.0, 'privatemem': 40685568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.042221875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38043648.0, 'privatemem': 40665088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 14.1191921875}} +{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37933056.0, 'privatemem': 40538112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.0314734375}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 356925440.0, 'privatemem': 1448673280.0, 'nonpaged': 2001264.0, 'virtualmem': 35157557248.0, 'time': 20.15775}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 354324480.0, 'privatemem': 1447530496.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.9642671875}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355999744.0, 'privatemem': 1446727680.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.937840625}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355708928.0, 'privatemem': 1447718912.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 21.3836453125}} +{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355086336.0, 'privatemem': 1448427520.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 20.5806625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40574976.0, 'privatemem': 42999808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.212690625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40849408.0, 'privatemem': 43442176.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.26136875}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40611840.0, 'privatemem': 43065344.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2927234375}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 35049472.0, 'privatemem': 37515264.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 14.2932515625}} +{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40902656.0, 'privatemem': 43450368.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.29265625}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437157888.0, 'privatemem': 1799569408.0, 'nonpaged': 2493704.0, 'virtualmem': 43789238272.0, 'time': 22.39598125}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 438943744.0, 'privatemem': 1800122368.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3933875}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 454443008.0, 'privatemem': 1816186880.0, 'nonpaged': 2493264.0, 'virtualmem': 43797430272.0, 'time': 22.156965625}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 441925632.0, 'privatemem': 1810481152.0, 'nonpaged': 2503344.0, 'virtualmem': 43973591040.0, 'time': 22.4793375}} +{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437071872.0, 'privatemem': 1798299648.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3045375}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43515904.0, 'privatemem': 45961216.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.59280625}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46112768.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.596046875}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43720704.0, 'privatemem': 46157824.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.590865625}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46100480.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.609971875}} +{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43429888.0, 'privatemem': 45940736.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.6273390625}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 516640768.0, 'privatemem': 2149273600.0, 'nonpaged': 2984784.0, 'virtualmem': 52399816704.0, 'time': 26.321934375}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 517148672.0, 'privatemem': 2152136704.0, 'nonpaged': 2986944.0, 'virtualmem': 52437565440.0, 'time': 26.177103125}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 523063296.0, 'privatemem': 2156064768.0, 'nonpaged': 2985504.0, 'virtualmem': 52412399616.0, 'time': 26.05946875}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 518561792.0, 'privatemem': 2162417664.0, 'nonpaged': 2994864.0, 'virtualmem': 52575977472.0, 'time': 28.18605}} +{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 525058048.0, 'privatemem': 2157924352.0, 'nonpaged': 2985264.0, 'virtualmem': 52408205312.0, 'time': 26.42195625}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40148992.0, 'privatemem': 42582016.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.0295875}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40206336.0, 'privatemem': 42512384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.990478125}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 45486080.0, 'privatemem': 47845376.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9103515625}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 44941312.0, 'privatemem': 47333376.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.9739078125}} +{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 46559232.0, 'privatemem': 49074176.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.99918125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 601858048.0, 'privatemem': 2509008896.0, 'nonpaged': 3485304.0, 'virtualmem': 61158797312.0, 'time': 28.8111328125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 604540928.0, 'privatemem': 2506592256.0, 'nonpaged': 3477504.0, 'virtualmem': 61023174656.0, 'time': 28.554359375}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 607997952.0, 'privatemem': 2508111872.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.05818125}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 606982144.0, 'privatemem': 2510180352.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.6098046875}} +{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 603512832.0, 'privatemem': 2506928128.0, 'nonpaged': 3478584.0, 'virtualmem': 61041356800.0, 'time': 30.173225}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42070016.0, 'privatemem': 44314624.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2156484375}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42672128.0, 'privatemem': 44982272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 16.160125}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42905600.0, 'privatemem': 45236224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2525890625}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 43896832.0, 'privatemem': 46153728.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.3214}} +{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42004480.0, 'privatemem': 44298240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.23181875}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 689721344.0, 'privatemem': 2865324032.0, 'nonpaged': 3968784.0, 'virtualmem': 69622706176.0, 'time': 31.0380265625}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 701034496.0, 'privatemem': 2882179072.0, 'nonpaged': 3982704.0, 'virtualmem': 69865975808.0, 'time': 31.334315625}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 685584384.0, 'privatemem': 2856980480.0, 'nonpaged': 3968664.0, 'virtualmem': 69621301248.0, 'time': 33.5692328125}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 697085952.0, 'privatemem': 2868523008.0, 'nonpaged': 3968784.0, 'virtualmem': 69637881856.0, 'time': 30.9457953125}} +{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 690245632.0, 'privatemem': 2862125056.0, 'nonpaged': 3970344.0, 'virtualmem': 69650661376.0, 'time': 33.4727609375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55869440.0, 'privatemem': 58114048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.7086890625}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 56160256.0, 'privatemem': 58540032.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 15.7096078125}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 49836032.0, 'privatemem': 52043776.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2957859375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55492608.0, 'privatemem': 57851904.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.5145359375}} +{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 47857664.0, 'privatemem': 50147328.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.8469078125}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 862195712.0, 'privatemem': 3575685120.0, 'nonpaged': 4952784.0, 'virtualmem': 86889738240.0, 'time': 40.3810609375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 865746944.0, 'privatemem': 3578298368.0, 'nonpaged': 4952304.0, 'virtualmem': 86881349632.0, 'time': 36.3784328125}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 869675008.0, 'privatemem': 3581808640.0, 'nonpaged': 4952544.0, 'virtualmem': 86885543936.0, 'time': 38.871209375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 860774400.0, 'privatemem': 3582889984.0, 'nonpaged': 4966464.0, 'virtualmem': 87128813568.0, 'time': 43.21194375}} +{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 855191552.0, 'privatemem': 3567927296.0, 'nonpaged': 4952904.0, 'virtualmem': 86877351936.0, 'time': 38.48225625}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57565184.0, 'privatemem': 59461632.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.1426484375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 54370304.0, 'privatemem': 56492032.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.101009375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 62488576.0, 'privatemem': 64598016.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.84624375}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57757696.0, 'privatemem': 59613184.0, 'nonpaged': 25640.0, 'virtualmem': 569163776.0, 'time': 15.9433421875}} +{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 67629056.0, 'privatemem': 69304320.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.0379890625}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028907008.0, 'privatemem': 4283650048.0, 'nonpaged': 5936184.0, 'virtualmem': 104104235008.0, 'time': 53.8624046875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037115392.0, 'privatemem': 4290715648.0, 'nonpaged': 5936304.0, 'virtualmem': 104120815616.0, 'time': 53.877346875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037705216.0, 'privatemem': 4291125248.0, 'nonpaged': 5935824.0, 'virtualmem': 104112427008.0, 'time': 54.8691671875}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1043337216.0, 'privatemem': 4301135872.0, 'nonpaged': 5935824.0, 'virtualmem': 104111026176.0, 'time': 46.317490625}} +{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028558848.0, 'privatemem': 4282368000.0, 'nonpaged': 5936424.0, 'virtualmem': 104108429312.0, 'time': 53.502359375}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73793536.0, 'privatemem': 75640832.0, 'nonpaged': 26600.0, 'virtualmem': 577552384.0, 'time': 16.6419671875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74006528.0, 'privatemem': 75755520.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 16.59216875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74121216.0, 'privatemem': 75894784.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.6399796875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 75317248.0, 'privatemem': 77017088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.6508421875}} +{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73236480.0, 'privatemem': 75030528.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.776903125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1193185280.0, 'privatemem': 4992319488.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 59.2310265625}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186713600.0, 'privatemem': 4982370304.0, 'nonpaged': 6919584.0, 'virtualmem': 121317330944.0, 'time': 62.308228125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1204101120.0, 'privatemem': 5004546048.0, 'nonpaged': 6919704.0, 'virtualmem': 121333911552.0, 'time': 59.4607328125}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186025472.0, 'privatemem': 4979195904.0, 'nonpaged': 6919824.0, 'virtualmem': 121321525248.0, 'time': 68.2966625}} +{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1190494208.0, 'privatemem': 4990369792.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 65.9037140625}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 69914624.0, 'privatemem': 71544832.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.5821546875}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 82804736.0, 'privatemem': 84516864.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4147265625}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 80211968.0, 'privatemem': 81952768.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 17.2119453125}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 72941568.0, 'privatemem': 74739712.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.0826671875}} +{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 57122816.0, 'privatemem': 59056128.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 15.8496921875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1363570688.0, 'privatemem': 5696401408.0, 'nonpaged': 7902864.0, 'virtualmem': 138542813184.0, 'time': 77.319371875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1359228928.0, 'privatemem': 5693067264.0, 'nonpaged': 7902504.0, 'virtualmem': 138522038272.0, 'time': 75.611196875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1382010880.0, 'privatemem': 5722746880.0, 'nonpaged': 7903224.0, 'virtualmem': 138563588096.0, 'time': 75.43135625}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1366474752.0, 'privatemem': 5719846912.0, 'nonpaged': 7935264.0, 'virtualmem': 139092529152.0, 'time': 77.2984921875}} +{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1380454400.0, 'privatemem': 5713457152.0, 'nonpaged': 7902744.0, 'virtualmem': 138555199488.0, 'time': 72.9519984375}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 82169856.0, 'privatemem': 84209664.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 18.2689421875}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 86765568.0, 'privatemem': 88666112.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 17.703690625}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89808896.0, 'privatemem': 91951104.0, 'nonpaged': 25744.0, 'virtualmem': 562872320.0, 'time': 17.698275}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 83464192.0, 'privatemem': 84893696.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.8156953125}} +{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89182208.0, 'privatemem': 91365376.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 17.637353125}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1688113152.0, 'privatemem': 7102902272.0, 'nonpaged': 9870744.0, 'virtualmem': 172987879424.0, 'time': 109.5945375}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681657856.0, 'privatemem': 7097241600.0, 'nonpaged': 9870264.0, 'virtualmem': 172979490816.0, 'time': 112.0583734375}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1701982208.0, 'privatemem': 7125585920.0, 'nonpaged': 9876984.0, 'virtualmem': 173109383168.0, 'time': 108.868828125}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1696256000.0, 'privatemem': 7110664192.0, 'nonpaged': 9870384.0, 'virtualmem': 172979556352.0, 'time': 100.987990625}} +{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681092608.0, 'privatemem': 7102992384.0, 'nonpaged': 9881424.0, 'virtualmem': 173160042496.0, 'time': 103.1147171875}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 88752128.0, 'privatemem': 90644480.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.194690625}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 91697152.0, 'privatemem': 93396992.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 19.1130046875}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 70430720.0, 'privatemem': 72364032.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 17.7690265625}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 85979136.0, 'privatemem': 87822336.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 19.166028125}} +{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 87728128.0, 'privatemem': 89387008.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.178809375}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2026475520.0, 'privatemem': 8518123520.0, 'nonpaged': 11837784.0, 'virtualmem': 207459684352.0, 'time': 140.7092328125}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2036518912.0, 'privatemem': 8542306304.0, 'nonpaged': 11840544.0, 'virtualmem': 207512752128.0, 'time': 147.6286140625}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2027098112.0, 'privatemem': 8528797696.0, 'nonpaged': 11837424.0, 'virtualmem': 207455424512.0, 'time': 157.0997796875}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2029830144.0, 'privatemem': 8523378688.0, 'nonpaged': 11838144.0, 'virtualmem': 207470809088.0, 'time': 149.35805}} +{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2018607104.0, 'privatemem': 8512258048.0, 'nonpaged': 11837544.0, 'virtualmem': 207443038208.0, 'time': 156.43776875}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 110104576.0, 'privatemem': 112001024.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 19.1979890625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 117399552.0, 'privatemem': 118956032.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.72220625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 102563840.0, 'privatemem': 104300544.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.6945328125}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 105697280.0, 'privatemem': 107380736.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.43420625}} +{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 106532864.0, 'privatemem': 108306432.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.3152046875}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2363232256.0, 'privatemem': 9939460096.0, 'nonpaged': 13804464.0, 'virtualmem': 241888612352.0, 'time': 184.053434375}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2365878272.0, 'privatemem': 9953259520.0, 'nonpaged': 13804344.0, 'virtualmem': 241900998656.0, 'time': 192.2616015625}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2358566912.0, 'privatemem': 9937661952.0, 'nonpaged': 13806264.0, 'virtualmem': 241918038016.0, 'time': 189.8282234375}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2342895616.0, 'privatemem': 9925849088.0, 'nonpaged': 13804224.0, 'virtualmem': 241884418048.0, 'time': 182.3936078125}} +{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2347986944.0, 'privatemem': 9933496320.0, 'nonpaged': 13804824.0, 'virtualmem': 241892872192.0, 'time': 186.212921875}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 130637824.0, 'privatemem': 132468736.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 20.00561875}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 115064832.0, 'privatemem': 116396032.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 20.3946609375}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 72556544.0, 'privatemem': 74584064.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 17.1177015625}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 112943104.0, 'privatemem': 114147328.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 20.2790203125}} +{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 129822720.0, 'privatemem': 131096576.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 20.95596875}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2690383872.0, 'privatemem': 11338743808.0, 'nonpaged': 15772944.0, 'virtualmem': 276378443776.0, 'time': 247.372325}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2684055552.0, 'privatemem': 11335376896.0, 'nonpaged': 15771504.0, 'virtualmem': 276344889344.0, 'time': 240.684809375}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2701897728.0, 'privatemem': 11360075776.0, 'nonpaged': 15772344.0, 'virtualmem': 276374052864.0, 'time': 235.606675}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2961162240.0, 'privatemem': 11630002176.0, 'nonpaged': 15773904.0, 'virtualmem': 276618567680.0, 'time': 277.3269875}} +{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2682052608.0, 'privatemem': 11340992512.0, 'nonpaged': 15776304.0, 'virtualmem': 276428775424.0, 'time': 244.7224234375}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 138235904.0, 'privatemem': 139558912.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 21.6494125}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 89427968.0, 'privatemem': 90931200.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4579984375}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 130588672.0, 'privatemem': 131649536.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 21.278078125}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 135176192.0, 'privatemem': 136491008.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 21.5131796875}} +{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 127688704.0, 'privatemem': 129499136.0, 'nonpaged': 26728.0, 'virtualmem': 581746688.0, 'time': 19.93003125}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3732779008.0, 'privatemem': 14553665536.0, 'nonpaged': 19709064.0, 'virtualmem': 345628565504.0, 'time': 353.601725}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3335438336.0, 'privatemem': 14157639680.0, 'nonpaged': 19704744.0, 'virtualmem': 345205465088.0, 'time': 356.084828125}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3416276992.0, 'privatemem': 14252584960.0, 'nonpaged': 19705824.0, 'virtualmem': 345296756736.0, 'time': 364.665215625}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3340185600.0, 'privatemem': 14166282240.0, 'nonpaged': 19705344.0, 'virtualmem': 345218048000.0, 'time': 330.89671875}} +{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3341864960.0, 'privatemem': 14169149440.0, 'nonpaged': 19707504.0, 'virtualmem': 345255796736.0, 'time': 352.603725}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 119099392.0, 'privatemem': 120713216.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 21.3428921875}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139829248.0, 'privatemem': 141701120.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 23.1737}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 151707648.0, 'privatemem': 153325568.0, 'nonpaged': 26488.0, 'virtualmem': 577552384.0, 'time': 22.1648703125}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139603968.0, 'privatemem': 141705216.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 24.3582796875}} +{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 126025728.0, 'privatemem': 128827392.0, 'nonpaged': 27568.0, 'virtualmem': 596426752.0, 'time': 21.027715625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3993194496.0, 'privatemem': 16967299072.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 480.1536890625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3999387648.0, 'privatemem': 16987381760.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 516.035265625}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4001804288.0, 'privatemem': 17038946304.0, 'nonpaged': 23718144.0, 'virtualmem': 415501574144.0, 'time': 483.755525}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4013903872.0, 'privatemem': 17002704896.0, 'nonpaged': 23639544.0, 'virtualmem': 414158938112.0, 'time': 503.345384375}} +{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4039008256.0, 'privatemem': 17174925312.0, 'nonpaged': 23918784.0, 'virtualmem': 419020464128.0, 'time': 505.355275}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 164077568.0, 'privatemem': 165376000.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 23.6242703125}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 136712192.0, 'privatemem': 138002432.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.1367515625}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 118976512.0, 'privatemem': 120524800.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 23.2383796875}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 127246336.0, 'privatemem': 128696320.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.4868671875}} +{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 201854976.0, 'privatemem': 202383360.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.734434375}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4636082176.0, 'privatemem': 19810603008.0, 'nonpaged': 27575064.0, 'virtualmem': 483073843200.0, 'time': 602.0996375}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4602040320.0, 'privatemem': 19810873344.0, 'nonpaged': 27579744.0, 'virtualmem': 483141148672.0, 'time': 659.99125625}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4591165440.0, 'privatemem': 19790200832.0, 'nonpaged': 27573024.0, 'virtualmem': 483023708160.0, 'time': 583.1214046875}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4639674368.0, 'privatemem': 19800694784.0, 'nonpaged': 27572544.0, 'virtualmem': 483015319552.0, 'time': 595.6076765625}} +{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4615213056.0, 'privatemem': 19768594432.0, 'nonpaged': 27572304.0, 'virtualmem': 483011125248.0, 'time': 585.95591875}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 122953728.0, 'privatemem': 124391424.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 22.2635234375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 128253952.0, 'privatemem': 129671168.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.54289375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 130244608.0, 'privatemem': 131567616.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 21.3423078125}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 120819712.0, 'privatemem': 121860096.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.1759359375}} +{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 197222400.0, 'privatemem': 197992448.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.0388765625}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5291032576.0, 'privatemem': 22605094912.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 769.2572203125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5268750336.0, 'privatemem': 22580580352.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 715.4761953125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5275197440.0, 'privatemem': 22597181440.0, 'nonpaged': 31506504.0, 'virtualmem': 551886561280.0, 'time': 743.6708078125}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5559996416.0, 'privatemem': 22927003648.0, 'nonpaged': 31508664.0, 'virtualmem': 552185012224.0, 'time': 777.7286765625}} +{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5265473536.0, 'privatemem': 22609494016.0, 'nonpaged': 31506384.0, 'virtualmem': 551898947584.0, 'time': 774.769990625}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 161509376.0, 'privatemem': 163639296.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 29.432303125}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 152326144.0, 'privatemem': 153423872.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 24.661028125}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 148279296.0, 'privatemem': 150319104.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 25.9785390625}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 153616384.0, 'privatemem': 154677248.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 25.02185}} +{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 154402816.0, 'privatemem': 155430912.0, 'nonpaged': 26360.0, 'virtualmem': 573358080.0, 'time': 25.0472640625}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6044577792.0, 'privatemem': 28556054528.0, 'nonpaged': 39377064.0, 'virtualmem': 690026848256.0, 'time': 238880.438532812}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6581481472.0, 'privatemem': 28245975040.0, 'nonpaged': 39374664.0, 'virtualmem': 689695236096.0, 'time': 1124.5557}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 5939179520.0, 'privatemem': 28300779520.0, 'nonpaged': 39375144.0, 'virtualmem': 689703624704.0, 'time': 61740.7140578125}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597120000.0, 'privatemem': 28281757696.0, 'nonpaged': 39374904.0, 'virtualmem': 689728397312.0, 'time': 1146.400846875}} +{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597758976.0, 'privatemem': 28234469376.0, 'nonpaged': 39375264.0, 'virtualmem': 689703690240.0, 'time': 1061.4835671875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 187748352.0, 'privatemem': 191131648.0, 'nonpaged': 26840.0, 'virtualmem': 581292032.0, 'time': 28.6244015625}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 186040320.0, 'privatemem': 189222912.0, 'nonpaged': 27448.0, 'virtualmem': 593874944.0, 'time': 27.09115625}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 191225856.0, 'privatemem': 192925696.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 27.2597046875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 182910976.0, 'privatemem': 184160256.0, 'nonpaged': 25760.0, 'virtualmem': 562872320.0, 'time': 26.3374671875}} +{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 178884608.0, 'privatemem': 179732480.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 26.914534375}} diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 23a4000..f09f0d9 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -4,6 +4,7 @@ // #include "cpprx/rx.hpp" +#include "cpplinq/linq.hpp" #include #include @@ -30,10 +31,135 @@ void PrintPrimes(int n) }); } +std::shared_ptr> Data( + string filename, + rxcpp::Scheduler::shared scheduler = std::make_shared() +); +string extract_value(const string& input, const string& key); + + +void run() +{ + using namespace cpplinq; + + struct item { + string args; + int concurrency; + double time; + + item(const string& input) { + args = extract_value(input, "args"); + concurrency = atoi( extract_value(input, "concurrency").c_str() ); + time = atof( extract_value(input, "time").c_str() ); + } + }; + + cout << "data >input ^parse and >(); + { + std::exception_ptr error; + std::condition_variable cv; + + std::mutex coutLock; + int inID = 0; + int parseID = 0; + int outID = 0; + + auto dataLines = Data( + "data.txt" +// , std::make_shared() + ); + auto input = std::make_shared(); + auto parsing = std::make_shared(); + auto output = std::make_shared(); + auto exp = rxcpp::from(dataLines) + .subscribe_on(input) + .select([&coutLock, &inID](const string& line) { + { + std::unique_lock guard(coutLock); + if (inID++ == 0) std::cout << std::this_thread::get_id(); + std::cout << '>' << std::flush; + } + return line; }) + .observe_on(parsing) + .select([&coutLock, &parseID](const string& line) { + { + std::unique_lock guard(coutLock); + if (parseID++ == 0) std::cout << std::this_thread::get_id(); + std::cout << '^' << std::flush; + } + return item(line); }) + .observe_on(output) +// .delay(std::chrono::milliseconds(10), output) + .subscribe( + [=, &coutLock, &outID](const item& i){ + { + std::unique_lock guard(coutLock); + if (outID++ == 0) std::cout << std::this_thread::get_id(); + std::cout << '<' << std::flush; + } + shared_data_parsed->push_back(i); }, + [&cv](){ + cv.notify_one();}, + [&cv, &error](const std::exception_ptr& e){ + error = e; cv.notify_one();}); + + std::mutex doneLock; + std::unique_lock guard(doneLock); + cv.wait(guard); + if (error != std::exception_ptr()) {std::rethrow_exception(error);} + cout << endl << "data loaded" << endl; + } + + auto data_parsed = shared_data_parsed.get(); + auto data = + from(*data_parsed) + .groupby([](const item& i) { return i.args; }); + + for (auto giter = data.begin(), end = data.end(); giter != end; ++giter) + { + const auto& g = *giter; + + cout << "arguments: " << g.key << endl; + + cout << "concurrency, mean, |, raw_data," << endl; + auto seq = + from(g) + .groupby([](const item& i) { return i.concurrency; }); + + for (auto giter = seq.begin(), end = seq.end(); giter != end; ++giter) + { + const auto& g = *giter; + + cout << g.key << ", "; + + auto times = from(g).select([](const item& i) { return i.time; }); + + auto n = from(g).count(); + auto sum = std::accumulate(times.begin(), times.end(), 0.0); + + cout << (sum / n) << ", |"; + + for (auto timeIter = times.begin(), end = times.end(); + timeIter != end; + ++timeIter) + { + cout << ", " << *timeIter; + } + cout << endl; + } + } +} int main(int argc, char* argv[]) { PrintPrimes(20); + + try { + run(); + } catch (exception& e) { + cerr << "exception: " << e.what() << endl; + } } bool IsPrime(int x) @@ -47,3 +173,77 @@ bool IsPrime(int x) return true; } +regex key_value_pair("'([^\']*)'\\s*[:,]\\s*(\\d+(?:\\.\\d+)?|'[^']*')"); + +string extract_value(const string& input, const string& key) +{ + const std::sregex_iterator end; + for (std::sregex_iterator i(input.cbegin(), input.cend(), key_value_pair); + i != end; + ++i) + { + if ((*i)[1] == key) + { + return (*i)[2]; + } + } + throw std::range_error("search key not found"); +} + +std::shared_ptr> Data( + string filename, + rxcpp::Scheduler::shared scheduler +) +{ + return rxcpp::CreateObservable( + [=](std::shared_ptr> observer) + -> rxcpp::Disposable + { + struct State + { + State(string filename) + : cancel(false), data(filename) { + if (data.fail()) { + throw logic_error("could not find file"); + } + } + bool cancel; + ifstream data; + }; + auto state = std::make_shared(std::move(filename)); + + rxcpp::ComposableDisposable cd; + + cd.Add(rxcpp::Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + rxcpp::fix0([=](rxcpp::Scheduler::shared s, std::function self) -> rxcpp::Disposable + { + try { + if (state->cancel) + return rxcpp::Disposable::Empty(); + + string line; + if (!!getline(state->data, line)) + { + observer->OnNext(std::move(line)); + return s->Schedule(std::move(self)); + } + else + { + observer->OnCompleted(); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + return rxcpp::Disposable::Empty(); + }) + )); + + return cd; + } + ); +} + diff --git a/Rx/CPP/testbench/testbench.vcxproj b/Rx/CPP/testbench/testbench.vcxproj index e357456..3f0ae00 100644 --- a/Rx/CPP/testbench/testbench.vcxproj +++ b/Rx/CPP/testbench/testbench.vcxproj @@ -44,13 +44,13 @@ true - $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\..\..\Ix\CPP\src;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ false - $(VCInstallDir)include;..\src;$(WindowsSDK_IncludePath); + $(VCInstallDir)include;..\..\..\Ix\CPP\src;..\src;$(WindowsSDK_IncludePath); $(SolutionDir)\bin\$(Configuration)\ obj\$(Configuration)\ diff --git a/Rx/CPP/testbench/testbench.vcxproj.filters b/Rx/CPP/testbench/testbench.vcxproj.filters index 2737526..8afd620 100644 --- a/Rx/CPP/testbench/testbench.vcxproj.filters +++ b/Rx/CPP/testbench/testbench.vcxproj.filters @@ -19,12 +19,4 @@ Source Files - - - Header Files - - - Header Files - - \ No newline at end of file -- GitLab From 803c2b5a9e68bacde47962cbbc86c875bdfb32ed Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 2 Mar 2013 22:46:57 -0800 Subject: [PATCH 027/782] added - orderby, foreach, publish and usage thereof --- Rx/CPP/src/cpprx/rx-base.hpp | 13 +- Rx/CPP/src/cpprx/rx-includes.hpp | 38 +++ Rx/CPP/src/cpprx/rx-operators.hpp | 244 +++++++++++++++--- .../{rx-scheduler.h => rx-scheduler.hpp} | 4 +- Rx/CPP/src/cpprx/rx-util.hpp | 4 +- Rx/CPP/src/cpprx/rx-windows.hpp | 3 + Rx/CPP/src/cpprx/rx.hpp | 145 ++++++----- Rx/CPP/testbench/testbench.cpp | 176 ++++++------- 8 files changed, 426 insertions(+), 201 deletions(-) create mode 100644 Rx/CPP/src/cpprx/rx-includes.hpp rename Rx/CPP/src/cpprx/{rx-scheduler.h => rx-scheduler.hpp} (99%) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index cf6642b..e5af503 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_BASE_HPP) #define CPPRX_RX_BASE_HPP -#pragma once namespace rxcpp { @@ -56,7 +58,14 @@ namespace rxcpp virtual ~Observable() {} }; - struct Scheduler : public std::enable_shared_from_this + template + struct GroupedObservable : Observable + { + virtual K Key() = 0; + virtual ~GroupedObservable() {} + }; + + struct Scheduler : public std::enable_shared_from_this { typedef std::chrono::steady_clock clock; typedef std::shared_ptr shared; diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp new file mode 100644 index 0000000..d5be690 --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -0,0 +1,38 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(CPPRX_RX_INCLUDES_HPP) +#define CPPRX_RX_INCLUDES_HPP + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rx-util.hpp" +#include "rx-base.hpp" +#include "rx-scheduler.hpp" +#include "rx-windows.hpp" +#include "rx-operators.hpp" + +#pragma pop_macro("min") +#pragma pop_macro("max") + +#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index e4250b1..cfd100d 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_OPERATORS_HPP) #define CPPRX_RX_OPERATORS_HPP -#pragma once namespace rxcpp { @@ -111,17 +113,60 @@ namespace rxcpp return p; } - template - class Subject : - public Observable, - public Observer, - public std::enable_shared_from_this> + + template + class ObservableSubject : + public Base, + public std::enable_shared_from_this { + protected: std::vector>> observers; + + void RemoveObserver(std::shared_ptr> toRemove) + { + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } public: - virtual void OnNext(const T& element) + + virtual Disposable Subscribe(std::shared_ptr> observer) { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d([wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }); + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(std::move(observer)); + return d; + } + }; + + template + class ObserverSubject : + public Base + { + public: + ObserverSubject() {} + + template + explicit ObserverSubject(A&& a) : Base(std::forward(a)) {} + + virtual void OnNext(const T& element) + { + for(auto& o : Base::observers) { try { @@ -137,7 +182,7 @@ namespace rxcpp } virtual void OnCompleted() { - for(auto& o : observers) + for(auto& o : Base::observers) { if (o) { o->OnCompleted(); @@ -147,7 +192,7 @@ namespace rxcpp } virtual void OnError(const std::exception_ptr& error) { - for(auto& o : observers) + for(auto& o : Base::observers) { if (o) { o->OnError(error); @@ -155,36 +200,12 @@ namespace rxcpp } } } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - for(auto& o : observers) - { - if (!o){ - o = std::move(observer); - return d; - } - } - observers.push_back(std::move(observer)); - return d; - } + }; - private: - void RemoveObserver(std::shared_ptr> toRemove) - { - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - *it = nullptr; - } + template + class Subject : + public ObserverSubject, Subject>> + { }; template @@ -193,6 +214,32 @@ namespace rxcpp return std::make_shared>(); } + template + class GroupedObservableSubject : + public Base + { + K key; + public: + GroupedObservableSubject(K key) : key(std::move(key)) {} + + virtual K Key() {return key;} + }; + + template + class GroupedSubject : + public ObserverSubject, GroupedSubject>>> + { + typedef ObserverSubject, GroupedSubject>>> base; + public: + GroupedSubject(K key) : base(std::move(key)) {} + }; + + template + std::shared_ptr> CreateGroupedSubject(K key) + { + return std::make_shared>(std::move(key)); + } + template struct fix0_thunk { F f; @@ -283,6 +330,36 @@ namespace rxcpp return source->Subscribe(observer); } + template + void ForEach( + const std::shared_ptr>& source, + typename util::identity>::type onNext + ) + { + std::mutex lock; + std::condition_variable wake; + bool done = false; + std::exception_ptr error; + auto observer = CreateObserver(std::move(onNext), [&]{ + std::unique_lock guard(lock); + done = true; + wake.notify_one(); + }, [&](const std::exception_ptr& e){ + std::unique_lock guard(lock); + done = true; + error = std::move(e); + wake.notify_one(); + }); + + source->Subscribe(observer); + + { + std::unique_lock guard(lock); + wake.wait(guard, [&]{return done;}); + } + + if (error != std::exception_ptr()) {std::rethrow_exception(error);} + } ////////////////////////////////////////////////////////////////////// // @@ -299,7 +376,7 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) { - return Subscribe( + return Subscribe( source, // on next [=](const T& element) @@ -353,6 +430,95 @@ namespace rxcpp }); } + template + auto GroupBy( + const std::shared_ptr>& source, + KS keySelector, + VS valueSelector, + L less) + -> std::shared_ptr::type, + typename std::decay::type>>>> + { + typedef typename std::decay::type Key; + typedef typename std::decay::type Value; + + typedef std::shared_ptr> LocalGroupObservable; + + return CreateObservable( + [=](std::shared_ptr> observer) + { + typedef std::function OnNext; + typedef std::function OnCompleted; + typedef std::function OnError; + + struct GroupValue + { + OnNext onNext; + OnCompleted onCompleted; + OnError onError; + }; + typedef std::map Groups; + + struct State + { + State(L less) : groups(std::move(less)) {} + std::mutex lock; + Groups groups; + }; + auto state = std::make_shared(std::move(less)); + + return Subscribe( + source, + // on next + [=](const T& element) + { + auto key = keySelector(element); + auto keySubject = CreateGroupedSubject(key); + + typename Groups::iterator groupIt; + bool newGroup = false; + GroupValue value; + value.onNext = [keySubject](Value v){ + keySubject->OnNext(std::move(v));}; + value.onCompleted = [keySubject](){ + keySubject->OnCompleted();}; + value.onError = [keySubject](const std::exception_ptr& e){ + keySubject->OnError(std::move(e));}; + + { + std::unique_lock guard(state->lock); + std::tie(groupIt, newGroup) = state->groups.insert(std::make_pair( + key,std::move(value)) + ); + } + + if (newGroup) + { + LocalGroupObservable nextGroup(std::move(keySubject)); + observer->OnNext(nextGroup); + } + groupIt->second.onNext(valueSelector(element)); + }, + // on completed + [=] + { + for(auto& group : state->groups) { + group.second.onCompleted(); + } + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + for(auto& group : state->groups) { + group.second.onError(error); + } + observer->OnError(error); + }); + }); + } + template std::shared_ptr> Take( const std::shared_ptr>& source, diff --git a/Rx/CPP/src/cpprx/rx-scheduler.h b/Rx/CPP/src/cpprx/rx-scheduler.hpp similarity index 99% rename from Rx/CPP/src/cpprx/rx-scheduler.h rename to Rx/CPP/src/cpprx/rx-scheduler.hpp index c2c16d6..5fcef15 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.h +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_SCHEDULERS_HPP) #define CPPRX_RX_SCHEDULERS_HPP -#pragma once namespace rxcpp { diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 32c4cd0..144fbc6 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -1,8 +1,10 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_UTIL_HPP) #define CPPRX_RX_UTIL_HPP -#pragma once #if !defined(RXCPP_THREAD_LOCAL) #if defined(_MSC_VER) diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 2c9bac9..72e636f 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -1,5 +1,8 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. +#pragma once +#include "rx-includes.hpp" + #if !defined(CPPRX_RX_WINDOWS_HPP) #define CPPRX_RX_WINDOWS_HPP #pragma once diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index f596bd0..848e945 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -1,110 +1,131 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. -#if !defined(CPPRX_RX_HPP) -#define CPPRX_RX_HPP #pragma once +#include "rx-includes.hpp" -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -#include "rx-util.hpp" -#include "rx-base.hpp" -#include "rx-scheduler.h" -#include "rx-windows.hpp" -#include "rx-operators.hpp" +#if !defined(CPPRX_RX_HPP) +#define CPPRX_RX_HPP namespace rxcpp { - template + template class Binder { Obj obj; + static T defaultValueSelector(T t){return std::move(t);} public: Binder(Obj obj) : obj(std::move(obj)) { } template - auto select(S selector) -> decltype(from(Select(obj, selector))) { - return from(Select(obj, selector)); + auto select(S selector) -> decltype(from(Select(obj, selector))) { + return from(Select(obj, selector)); } template - auto where(P predicate) -> decltype(from(Where(obj, predicate))) { - return from(Where(obj, predicate)); + auto where(P predicate) -> decltype(from(Where(obj, predicate))) { + return from(Where(obj, predicate)); + } + Obj publish() { + return obj; + } + template + auto group_by( + KS keySelector) + -> decltype(from(GroupBy(obj, keySelector, defaultValueSelector, std::less()))) { + return from(GroupBy(obj, keySelector, defaultValueSelector, std::less())); + } + template + auto group_by( + KS keySelector, + VS valueSelector) + -> decltype(from(GroupBy(obj, keySelector, valueSelector, std::less()))) { + return from(GroupBy(obj, keySelector, valueSelector, std::less())); + } + template + auto group_by( + KS keySelector, + VS valueSelector, + L less) + -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { + return from(GroupBy(obj, keySelector, valueSelector, less)); } template - auto take(Integral n) -> decltype(from(Take(obj, n))) { - return from(Take(obj, n)); + auto take(Integral n) -> decltype(from(Take(obj, n))) { + return from(Take(obj, n)); } - auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { - return from(Delay(obj, due)); + auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { + return from(Delay(obj, due)); } - auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { - return from(Delay(obj, due, scheduler)); + auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { + return from(Delay(obj, due, scheduler)); } - auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { - return from(LimitWindow(obj, milliseconds)); + auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { + return from(LimitWindow(obj, milliseconds)); } - auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { - return from(DistinctUntilChanged(obj)); + auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { + return from(DistinctUntilChanged(obj)); } auto subscribe_on(Scheduler::shared scheduler) - -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) + -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) { - return from(SubscribeOnObservable(obj, std::move(scheduler))); + return from(SubscribeOnObservable(obj, std::move(scheduler))); } auto observe_on(Scheduler::shared scheduler) - -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) + -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) { - return from(ObserveOnObserver(obj, std::move(scheduler))); + return from(ObserveOnObserver(obj, std::move(scheduler))); } auto on_dispatcher() - -> decltype(from(ObserveOnDispatcher(obj))) + -> decltype(from(ObserveOnDispatcher(obj))) { - return from(ObserveOnDispatcher(obj)); + return from(ObserveOnDispatcher(obj)); + } + template + void for_each(OnNext onNext) { + ForEach(obj, onNext); } template - auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - auto result = Subscribe(obj, onNext); + auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { + auto result = Subscribe(obj, onNext); return result; } template - auto subscribe(OnNext onNext, OnComplete onComplete) -> decltype(Subscribe(obj, onNext, onComplete)) { - auto result = Subscribe(obj, onNext, onComplete); + auto subscribe(OnNext onNext, OnComplete onComplete) + -> decltype(Subscribe(obj, onNext, onComplete)) { + auto result = Subscribe(obj, onNext, onComplete); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) - -> decltype(Subscribe(obj, onNext, onComplete, onError)) { - auto result = Subscribe(obj, onNext, onComplete, onError); + -> decltype(Subscribe(obj, onNext, onComplete, onError)) { + auto result = Subscribe(obj, onNext, onComplete, onError); return result; } }; - template - Binder::type> from(Obj&& obj) { - return Binder::type>(std::forward(obj)); } -} + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } + + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } -#pragma pop_macro("min") -#pragma pop_macro("max") + template + Binder from(Binder binder) { + return std::move(binder); } + + template + T item(const Binder>>&); + + template + T item(const Binder>>&); + + template + T item(const std::shared_ptr>&); + + template + T item(const std::shared_ptr>&); +} #endif diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index f09f0d9..01f08c8 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -7,6 +7,7 @@ #include "cpplinq/linq.hpp" #include +#include #include #include #include @@ -37,7 +38,6 @@ std::shared_ptr> Data( ); string extract_value(const string& input, const string& key); - void run() { using namespace cpplinq; @@ -54,101 +54,85 @@ void run() } }; - cout << "data >input ^parse and >(); - { - std::exception_ptr error; - std::condition_variable cv; - - std::mutex coutLock; - int inID = 0; - int parseID = 0; - int outID = 0; - - auto dataLines = Data( - "data.txt" -// , std::make_shared() - ); - auto input = std::make_shared(); - auto parsing = std::make_shared(); - auto output = std::make_shared(); - auto exp = rxcpp::from(dataLines) - .subscribe_on(input) - .select([&coutLock, &inID](const string& line) { - { - std::unique_lock guard(coutLock); - if (inID++ == 0) std::cout << std::this_thread::get_id(); - std::cout << '>' << std::flush; - } - return line; }) - .observe_on(parsing) - .select([&coutLock, &parseID](const string& line) { - { - std::unique_lock guard(coutLock); - if (parseID++ == 0) std::cout << std::this_thread::get_id(); - std::cout << '^' << std::flush; - } - return item(line); }) - .observe_on(output) -// .delay(std::chrono::milliseconds(10), output) - .subscribe( - [=, &coutLock, &outID](const item& i){ - { - std::unique_lock guard(coutLock); - if (outID++ == 0) std::cout << std::this_thread::get_id(); - std::cout << '<' << std::flush; - } - shared_data_parsed->push_back(i); }, - [&cv](){ - cv.notify_one();}, - [&cv, &error](const std::exception_ptr& e){ - error = e; cv.notify_one();}); - - std::mutex doneLock; - std::unique_lock guard(doneLock); - cv.wait(guard); - if (error != std::exception_ptr()) {std::rethrow_exception(error);} - cout << endl << "data loaded" << endl; - } - - auto data_parsed = shared_data_parsed.get(); - auto data = - from(*data_parsed) - .groupby([](const item& i) { return i.args; }); - - for (auto giter = data.begin(), end = data.end(); giter != end; ++giter) - { - const auto& g = *giter; - - cout << "arguments: " << g.key << endl; - - cout << "concurrency, mean, |, raw_data," << endl; - auto seq = - from(g) - .groupby([](const item& i) { return i.concurrency; }); - - for (auto giter = seq.begin(), end = seq.end(); giter != end; ++giter) - { - const auto& g = *giter; - - cout << g.key << ", "; - - auto times = from(g).select([](const item& i) { return i.time; }); - - auto n = from(g).count(); - auto sum = std::accumulate(times.begin(), times.end(), 0.0); - - cout << (sum / n) << ", |"; - - for (auto timeIter = times.begin(), end = times.end(); - timeIter != end; - ++timeIter) - { - cout << ", " << *timeIter; - } - cout << endl; - } - } + auto input = std::make_shared(); + auto output = std::make_shared(); + + auto dataLines = Data("data.txt"); + + int arggroupcount = 0; + + rxcpp::from(dataLines) + .subscribe_on(input) + // parse input into items + .select([](const string& line) { + return item(line);} + ) + // group items by args field + .group_by([](const item& i) { + return i.args;} + ) + .select([=](const std::shared_ptr> & gob){ + return std::make_pair( + gob->Key(), // keep args key + rxcpp::from(gob) + // group items by concurrency field + .group_by([](const item& i){ + return i.concurrency;} + ) + // select only the times field + .select([=] (const std::shared_ptr> & gob){ + return std::make_pair( + gob->Key(), // keep concurrency key + rxcpp::from(gob) + .select([](const item& i){ + return i.time;} + ) + .publish());} + ) + .publish());} + ) + .observe_on(output) + // print the grouped results + // for_each the args to block until the nested subscribes have finished + .for_each([&](const std::pair, std::shared_ptr > > > > >& ob){ + auto argsstate = std::make_shared>(false, ob.first, arggroupcount++); + rxcpp::from(ob.second) + // subscribe the concurrencies within each args + .subscribe([=](const std::pair > >& ob){ + auto linestate = std::make_shared>>(ob.first, std::vector()); + rxcpp::from(ob.second) + // subscribe the times within each concurrency + .subscribe([=](const double& i){ + // collect the times + linestate->second.push_back(i); + },[=]{ + // this concurrency's times are complete + // output a line to the console. + + if (!std::get<0>(*argsstate)) + { + std::get<0>(*argsstate) = true; + cout<<"arguments: "<(*argsstate)<first << ", "; + + auto n = from(linestate->second).count(); + auto sum = std::accumulate(linestate->second.begin(), linestate->second.end(), 0.0); + + cout << (sum / n) << ", |"; + + for (auto timeIter = linestate->second.begin(), end = linestate->second.end(); + timeIter != end; + ++timeIter) + { + cout << ", " << *timeIter; + } + cout << endl; + }); + }); + }); } int main(int argc, char* argv[]) -- GitLab From e786ae6cfda6021e88a05182023aea6c62affe4c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 8 Mar 2013 14:42:37 -0800 Subject: [PATCH 028/782] added select_many, traits and ADL chain also fix threading bugs and improve operator syntax and fixes for bugs found on windows --- Ix/CPP/src/IxCpp.vcxproj | 65 ++++++++++ Ix/CPP/src/IxCpp.vcxproj.filters | 55 +++++++++ Rx/CPP/src/RxCpp.vcxproj | 61 ++++++++++ Rx/CPP/src/RxCpp.vcxproj.filters | 43 +++++++ Rx/CPP/src/cpprx/rx-base.hpp | 37 ++++-- Rx/CPP/src/cpprx/rx-includes.hpp | 27 +++++ Rx/CPP/src/cpprx/rx-operators.hpp | 194 +++++++++++++++++++++++++++--- Rx/CPP/src/cpprx/rx-scheduler.hpp | 4 +- Rx/CPP/src/cpprx/rx-windows.hpp | 165 ++++++++++++++++++++----- Rx/CPP/src/cpprx/rx.hpp | 188 +++++++++++++++++++++-------- 10 files changed, 722 insertions(+), 117 deletions(-) create mode 100644 Ix/CPP/src/IxCpp.vcxproj create mode 100644 Ix/CPP/src/IxCpp.vcxproj.filters create mode 100644 Rx/CPP/src/RxCpp.vcxproj create mode 100644 Rx/CPP/src/RxCpp.vcxproj.filters diff --git a/Ix/CPP/src/IxCpp.vcxproj b/Ix/CPP/src/IxCpp.vcxproj new file mode 100644 index 0000000..9367080 --- /dev/null +++ b/Ix/CPP/src/IxCpp.vcxproj @@ -0,0 +1,65 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {65483A0D-1D72-47CC-B147-27415FFC1FC3} + MakeFileProj + + + + Makefile + true + v110 + + + Makefile + false + v110 + + + + + + + + + + + + + WIN32;_DEBUG;$(NMakePreprocessorDefinitions) + + + WIN32;NDEBUG;$(NMakePreprocessorDefinitions) + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Ix/CPP/src/IxCpp.vcxproj.filters b/Ix/CPP/src/IxCpp.vcxproj.filters new file mode 100644 index 0000000..dd7d5bc --- /dev/null +++ b/Ix/CPP/src/IxCpp.vcxproj.filters @@ -0,0 +1,55 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/Rx/CPP/src/RxCpp.vcxproj b/Rx/CPP/src/RxCpp.vcxproj new file mode 100644 index 0000000..7a7398f --- /dev/null +++ b/Rx/CPP/src/RxCpp.vcxproj @@ -0,0 +1,61 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {A912FB36-33A7-4DDA-A7D6-D17F9495A623} + MakeFileProj + + + + Makefile + true + v110 + + + Makefile + false + v110 + + + + + + + + + + + + + WIN32;_DEBUG;$(NMakePreprocessorDefinitions) + + + WIN32;NDEBUG;$(NMakePreprocessorDefinitions) + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx/CPP/src/RxCpp.vcxproj.filters b/Rx/CPP/src/RxCpp.vcxproj.filters new file mode 100644 index 0000000..2ce3d34 --- /dev/null +++ b/Rx/CPP/src/RxCpp.vcxproj.filters @@ -0,0 +1,43 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index e5af503..6182d0c 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -261,25 +261,13 @@ namespace rxcpp LocalScheduler(const LocalScheduler&); public: - static void DoNoThrow(Work& work, Scheduler::shared scheduler) throw() + static void Do(Work& work, Scheduler::shared scheduler) throw() { if (work) { work(std::move(scheduler)); } } - static void Do(Work& work, Scheduler::shared scheduler) - { - try { - DoNoThrow(work, std::move(scheduler)); - } catch (const std::exception& ) { - // work must catch all expected exceptions - std::unexpected(); - } catch (...) { - // work must catch all expected exceptions - std::unexpected(); - } - } public: LocalScheduler() @@ -305,5 +293,28 @@ namespace rxcpp } }; + template + T item(const std::shared_ptr>&); + + template + T item(const std::shared_ptr>&); + + template + struct is_observable {static const bool value = false;}; + + template + struct is_observable>> {static const bool value = true;}; + + template + struct is_observable>> {static const bool value = true;}; + + template + struct observable_item; + + template + struct observable_item>> {typedef T type;}; + + template + struct observable_item>> {typedef T type;}; } #endif diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index d5be690..e0574aa 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -26,6 +26,33 @@ #include #include +// some configuration macros +#if defined(_MSC_VER) + +#if _MSC_VER > 1600 +#define RXCPP_USE_RVALUEREF 1 +#define RXCPP_USE_VARIADIC_TEMPLATES 0 +#endif + +#if _CPPRTTI +#define RXCPP_USE_RTTI 1 +#endif + +#elif defined(__clang__) + +#if __has_feature(cxx_rvalue_references) +#define RXCPP_USE_RVALUEREF 1 +#endif +#if __has_feature(cxx_rtti) +#define RXCPP_USE_RTTI 1 +#endif +#if __has_feature(cxx_variadic_templates) +#define RXCPP_USE_VARIADIC_TEMPLATES 1 +#endif + +#endif + + #include "rx-util.hpp" #include "rx-base.hpp" #include "rx-scheduler.hpp" diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index cfd100d..29b489f 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -120,10 +120,12 @@ namespace rxcpp public std::enable_shared_from_this { protected: + std::mutex lock; std::vector>> observers; void RemoveObserver(std::shared_ptr> toRemove) { + std::unique_lock guard(lock); auto it = std::find(begin(observers), end(observers), toRemove); if (it != end(observers)) *it = nullptr; @@ -142,14 +144,17 @@ namespace rxcpp } }); - for(auto& o : observers) { - if (!o){ - o = std::move(observer); - return d; + std::unique_lock guard(lock); + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } } + observers.push_back(std::move(observer)); } - observers.push_back(std::move(observer)); return d; } }; @@ -166,37 +171,45 @@ namespace rxcpp virtual void OnNext(const T& element) { - for(auto& o : Base::observers) + std::unique_lock guard(Base::lock); + auto local = Base::observers; + guard.unlock(); + for(auto& o : local) { try { - if (o) + if (o) { o->OnNext(element); + } } catch (...) { - auto o_ = std::move(o); - o_->OnError(std::current_exception()); + o->OnError(std::current_exception()); + Base::RemoveObserver(o); } } } virtual void OnCompleted() { - for(auto& o : Base::observers) + std::unique_lock guard(Base::lock); + auto local = std::move(Base::observers); + guard.unlock(); + for(auto& o : local) { if (o) { o->OnCompleted(); - o = nullptr; } } } virtual void OnError(const std::exception_ptr& error) { - for(auto& o : Base::observers) + std::unique_lock guard(Base::lock); + auto local = std::move(Base::observers); + guard.unlock(); + for(auto& o : local) { if (o) { o->OnError(error); - o = nullptr; } } } @@ -317,15 +330,16 @@ namespace rxcpp // // imperative functions - template + template Disposable Subscribe( - const std::shared_ptr>& source, - typename util::identity>::type onNext, + const S& source, + typename util::identity::type&)>>::type onNext, std::function onCompleted = nullptr, std::function onError = nullptr ) { - auto observer = CreateObserver(std::move(onNext), std::move(onCompleted), std::move(onError)); + auto observer = CreateObserver::type>( + std::move(onNext), std::move(onCompleted), std::move(onError)); return source->Subscribe(observer); } @@ -376,7 +390,7 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) { - return Subscribe( + return Subscribe( source, // on next [=](const T& element) @@ -396,6 +410,146 @@ namespace rxcpp }); }); } + + template + struct reveal_type {private: reveal_type();}; + + template + auto SelectMany( + const std::shared_ptr>& source, + CS collectionSelector, + RS resultSelector) + -> const std::shared_ptr::type>::type&)>::type>> + { + typedef typename std::result_of::type C; + typedef typename observable_item::type CI; + typedef typename std::result_of::type U; + + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + size_t subscribed; + bool cancel; + std::mutex lock; + }; + auto state = std::make_shared(); + state->cancel = false; + state->subscribed = 0; + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + std::unique_lock guard(state->lock); + state->cancel = true; }) + ); + + ++state->subscribed; + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + if (!cancel) ++state->subscribed; + } + if (!cancel) { + try { + auto collection = collectionSelector(element); + cd.Add(Subscribe( + collection, + // on next + [=](const CI& element) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + try { + if (!cancel) { + auto result = resultSelector(element); + observer->OnNext(std::move(result)); + } + } catch (...) { + observer->OnError(std::current_exception()); + cd.Dispose(); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + finished = (--state->subscribed) == 0; + cancel = state->cancel; + } + if (!cancel && finished) + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + --state->subscribed; + cancel = state->cancel; + } + if (!cancel) + observer->OnError(error); + cd.Dispose(); + })); + } catch (...) { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + } + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + finished = (--state->subscribed) == 0; + cancel = state->cancel; + } + if (!cancel && finished) + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + --state->subscribed; + cancel = state->cancel; + } + if (!cancel) + observer->OnError(error); + })); + return cd; + }); + } template const std::shared_ptr> Where( @@ -577,9 +731,8 @@ namespace rxcpp std::shared_ptr> Delay( const std::shared_ptr>& source, Scheduler::clock::duration due, - Scheduler::shared scheduler = nullptr) + Scheduler::shared scheduler) { - if (!scheduler) {scheduler = std::make_shared();} return CreateObservable( [=](std::shared_ptr> observer) -> Disposable @@ -685,6 +838,7 @@ namespace rxcpp -> Disposable { struct State { + State() : last(), hasValue(false) {} T last; bool hasValue; }; diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 5fcef15..037e41e 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -103,6 +103,7 @@ namespace rxcpp virtual Disposable Schedule(clock::time_point dueTime, Work work) { auto ct = std::make_shared(); + std::this_thread::sleep_until(dueTime); Do(work, ct); return Disposable::Empty(); } @@ -183,7 +184,8 @@ namespace rxcpp if (++trampoline == 1) { auto local = shared_from_this(); - result.set(factory([local]{local->Run();})); + result.set(factory([local]{ + local->Run();})); // trampoline lifetime is now owned by the thread unwindTrampoline.dismiss(); } diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 72e636f..31b932b 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -93,78 +93,181 @@ namespace rxcpp { namespace win32 { class WindowScheduler : public rxcpp::LocalScheduler { - HWND hwnd; - Scheduler::shared ct; + + struct compare_work + { + template + bool operator()(const T& work1, const T& work2) const { + return work1.first > work2.first; + } + }; + + struct Queue; + typedef std::pair Item; + typedef std::priority_queue< + std::pair>, + std::vector>>, + compare_work + > ScheduledWork; + + struct Queue + { + Queue() : exit(false), window(NULL) {} + bool exit; + HWND window; + ScheduledWork scheduledWork; + mutable std::mutex lock; + }; + struct WindowClass { + std::shared_ptr queue; + static const wchar_t* const className(){ return L"rxcpp::win32::WindowScheduler::WindowClass"; } WindowClass() { - WNDCLASS wndclass = {}; + } + + static void Create(const std::shared_ptr& queue) + { + WNDCLASSW wndclass = {}; wndclass.style = 0; wndclass.lpfnWndProc = &WndProc; - wndclass.cbClsExtra; wndclass.cbWndExtra = 0; wndclass.hInstance = NULL; wndclass.lpszClassName = className(); - if (!RegisterClass(&wndclass)) + if (!RegisterClassW(&wndclass)) throw std::exception("failed to register windows class"); + std::unique_ptr that(new WindowClass); + that->queue = queue; + + queue->window = CreateWindowExW(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, reinterpret_cast(that.get())); + if (!queue->window) + throw std::exception("create window failed"); + + that.release(); } - HWND CreateWindow_() - { - return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); - } + static const int WM_USER_DISPATCH = WM_USER + 1; static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { + static WindowClass* windowClass; switch (message) { - // TODO: shatter attack surface. should validate the message, e.g. using a handle table. + case WM_NCCREATE: + { + windowClass = reinterpret_cast(reinterpret_cast(lParam)->lpCreateParams); + } + break; + case WM_NCDESTROY: + { + delete windowClass; + windowClass = nullptr; + } + break; + case WM_TIMER: case WM_USER_DISPATCH: - ((void(*)(void*))wParam)((void*)lParam); + { + bool destroy = false; + HWND window = NULL; + { + std::unique_lock guard(windowClass->queue->lock); + + while (!windowClass->queue->scheduledWork.empty() && !windowClass->queue->scheduledWork.top().second.get()->second) + { + // discard the disposed items + windowClass->queue->scheduledWork.pop(); + } + + if (!windowClass->queue->scheduledWork.empty()) + { + auto& item = windowClass->queue->scheduledWork.top(); + auto now = item.second.get()->first->Now(); + + // wait until the work is due + if(now < item.first) + { + auto remaining = std::chrono::duration_cast(item.first - now).count(); + if (remaining >= USER_TIMER_MINIMUM) + { + return SetTimer(hwnd, 0, static_cast(remaining), nullptr); + } + std::this_thread::sleep_until(item.first); + } + + // dispatch work + auto work = std::move(item.second.get()->second); + auto scheduler = std::move(item.second.get()->first); + windowClass->queue->scheduledWork.pop(); + + { + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + LocalScheduler::Do(work, scheduler); + work = nullptr; + scheduler = nullptr; + } + + if (!windowClass->queue->scheduledWork.empty()) + { + ::PostMessageW(windowClass->queue->window, WindowClass::WM_USER_DISPATCH, 0, 0); + } + } + + destroy = windowClass->queue->exit && windowClass->queue->scheduledWork.empty(); + window = windowClass->queue->window; + } + + if (destroy) + { + DestroyWindow(window); + } + } return 0; default: - return DefWindowProc(hwnd, message, wParam, lParam); + break; } - } - static WindowClass& Instance() { - static WindowClass instance; - return instance; + return DefWindowProcW(hwnd, message, wParam, lParam); } }; - static void run_proc( - void* pvfn - ) - { - std::unique_ptr f((Item*)(void*) pvfn); - Do(f->second, f->first); - } + std::shared_ptr queue; public: WindowScheduler() - : hwnd(WindowClass::Instance().CreateWindow_()) - , ct(std::make_shared()) + : queue(std::make_shared()) { - if (!hwnd) - throw std::exception("create window failed"); + WindowClass::Create(queue); } ~WindowScheduler() { // send one last message to ourselves to shutdown. - Schedule([=](Scheduler::shared){ CloseWindow(hwnd); return Disposable::Empty();}); + { + std::unique_lock guard(queue->lock); + queue->exit = true; + } + ::PostMessageW(queue->window, WindowClass::WM_USER_DISPATCH, 0, 0); } using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { - std::unique_ptr f(new Item(ct, std::move(work))); - ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)f.release()); - return Disposable::Empty(); + auto cancelable = std::make_shared(std::make_pair(get(), std::move(work))); + { + std::unique_lock guard(queue->lock); + queue->scheduledWork.push(std::make_pair(dueTime, cancelable)); + } + ::PostMessageW(queue->window, WindowClass::WM_USER_DISPATCH, 0, 0); + auto local = queue; + return Disposable([local, cancelable]{ + std::unique_lock guard(local->lock); + cancelable.get()->second = nullptr; + ::PostMessageW(local->window, WindowClass::WM_USER_DISPATCH, 0, 0); + }); } }; } } diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 848e945..b5a75cb 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -7,23 +7,101 @@ #define CPPRX_RX_HPP namespace rxcpp -{ +{ template - class Binder + class BinderBase { + protected: Obj obj; - static T defaultValueSelector(T t){return std::move(t);} + + struct pass_through { + template + X operator()(X x) const {return std::move(x);} + }; + public: + typedef T item_type; + typedef Obj observable_type; + + BinderBase(Obj obj) : obj(std::move(obj)) + { + } + }; + + template + class BinderNested; + + template + class BinderNested : public BinderBase + { + protected: + typedef BinderBase base; + typedef typename base::item_type item_type; + typedef typename base::pass_through pass_through; + using base::obj; public: - Binder(Obj obj) : obj(std::move(obj)) + static const bool is_item_observable = false; + BinderNested(Obj obj) : BinderBase(std::move(obj)) { } + }; + + template + class BinderNested : public BinderBase + { + protected: + typedef BinderBase base; + typedef typename base::item_type item_type; + typedef typename base::pass_through pass_through; + using base::obj; + public: + static const bool is_item_observable = true; + + BinderNested(Obj obj) : base(std::move(obj)) + { + } + + auto select_many() + -> decltype(from(SelectMany(obj, pass_through(), pass_through()))) { + return from(SelectMany(obj, pass_through(), pass_through())); + } + template + auto select_many(CS collectionSelector) + -> decltype(from(SelectMany(obj, std::move(collectionSelector), pass_through()))) { + return from(SelectMany(obj, std::move(collectionSelector), pass_through())); + } + template + auto select_many(CS collectionSelector, RS resultSelector) + -> decltype(from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector)))) { + return from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector))); + } + }; + + template + class Binder : public BinderNested< + typename observable_item::type, + Obj, + is_observable::type>::value> + { + typedef BinderNested< + typename observable_item::type, + Obj, + is_observable::type>::value> base; + typedef typename base::item_type item_type; + typedef typename base::pass_through pass_through; + using base::obj; + public: + + Binder(Obj obj) : base(std::move(obj)) + { + } + template - auto select(S selector) -> decltype(from(Select(obj, selector))) { - return from(Select(obj, selector)); + auto select(S selector) -> decltype(from(Select(obj, selector))) { + return from(Select(obj, selector)); } template - auto where(P predicate) -> decltype(from(Where(obj, predicate))) { - return from(Where(obj, predicate)); + auto where(P predicate) -> decltype(from(Where(obj, predicate))) { + return from(Where(obj, predicate)); } Obj publish() { return obj; @@ -31,101 +109,107 @@ namespace rxcpp template auto group_by( KS keySelector) - -> decltype(from(GroupBy(obj, keySelector, defaultValueSelector, std::less()))) { - return from(GroupBy(obj, keySelector, defaultValueSelector, std::less())); + -> decltype(from(GroupBy(obj, keySelector, pass_through(), std::less()))) { + return from(GroupBy(obj, keySelector, pass_through(), std::less())); } template auto group_by( KS keySelector, VS valueSelector) - -> decltype(from(GroupBy(obj, keySelector, valueSelector, std::less()))) { - return from(GroupBy(obj, keySelector, valueSelector, std::less())); + -> decltype(from(GroupBy(obj, keySelector, valueSelector, std::less()))) { + return from(GroupBy(obj, keySelector, valueSelector, std::less())); } template auto group_by( KS keySelector, VS valueSelector, L less) - -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { - return from(GroupBy(obj, keySelector, valueSelector, less)); + -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { + return from(GroupBy(obj, keySelector, valueSelector, less)); } template - auto take(Integral n) -> decltype(from(Take(obj, n))) { - return from(Take(obj, n)); + auto take(Integral n) -> decltype(from(Take(obj, n))) { + return from(Take(obj, n)); } - auto delay(Scheduler::clock::duration due) -> decltype(from(Delay(obj, due))) { - return from(Delay(obj, due)); + auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { + return from(Delay(obj, due, scheduler)); } - auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { - return from(Delay(obj, due, scheduler)); + auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { + return from(LimitWindow(obj, milliseconds)); } - auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { - return from(LimitWindow(obj, milliseconds)); - } - auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { - return from(DistinctUntilChanged(obj)); + auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { + return from(DistinctUntilChanged(obj)); } auto subscribe_on(Scheduler::shared scheduler) - -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) + -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) { - return from(SubscribeOnObservable(obj, std::move(scheduler))); + return from(SubscribeOnObservable(obj, std::move(scheduler))); } auto observe_on(Scheduler::shared scheduler) - -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) + -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) { - return from(ObserveOnObserver(obj, std::move(scheduler))); + return from(ObserveOnObserver(obj, std::move(scheduler))); } auto on_dispatcher() - -> decltype(from(ObserveOnDispatcher(obj))) + -> decltype(from(ObserveOnDispatcher(obj))) { - return from(ObserveOnDispatcher(obj)); + return from(ObserveOnDispatcher(obj)); } template void for_each(OnNext onNext) { - ForEach(obj, onNext); + ForEach(obj, onNext); } template - auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - auto result = Subscribe(obj, onNext); + auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { + auto result = Subscribe(obj, onNext); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete) - -> decltype(Subscribe(obj, onNext, onComplete)) { - auto result = Subscribe(obj, onNext, onComplete); + -> decltype(Subscribe(obj, onNext, onComplete)) { + auto result = Subscribe(obj, onNext, onComplete); return result; } template auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) - -> decltype(Subscribe(obj, onNext, onComplete, onError)) { - auto result = Subscribe(obj, onNext, onComplete, onError); + -> decltype(Subscribe(obj, onNext, onComplete, onError)) { + auto result = Subscribe(obj, onNext, onComplete, onError); return result; } +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto chain(Arg&& ...arg) + -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)...))) { + return from(rxcpp_chain(Tag(), obj, std::forward(arg)...)); + } +#endif }; template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } - - template - Binder from(Binder binder) { - return std::move(binder); } + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } template - T item(const Binder>>&); + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } + + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } - template - T item(const Binder>>&); + template + Binder from(Binder binder) { + return std::move(binder); } template - T item(const std::shared_ptr>&); + T item(const Binder>>&); - template - T item(const std::shared_ptr>&); + template + T item(const Binder>>&); } #endif -- GitLab From c401e4c4d61da2c75ef6f28d43b7848ecf708267 Mon Sep 17 00:00:00 2001 From: malayeri Date: Fri, 22 Mar 2013 22:58:05 -0700 Subject: [PATCH 029/782] Merge remote-tracking branch 'codeplex/master' into codeplex -- GitLab From 61c8ef9f314f6e83f2c07f1145852e210a83e1e3 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 23 Mar 2013 00:44:56 -0700 Subject: [PATCH 030/782] Add zip, combine_latest and merge - rewrite schedulers --- Rx/CPP/src/cpprx/rx-operators.hpp | 414 +++++++++++++++++++++--- Rx/CPP/src/cpprx/rx-scheduler.hpp | 521 ++++++++++++++++++------------ Rx/CPP/src/cpprx/rx-util.hpp | 56 ++++ Rx/CPP/src/cpprx/rx-windows.hpp | 2 + Rx/CPP/src/cpprx/rx.hpp | 52 ++- Rx/CPP/testbench/testbench.cpp | 188 ++++++++++- 6 files changed, 979 insertions(+), 254 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 29b489f..a2e8b3c 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -28,7 +28,7 @@ namespace rxcpp if (CurrentThreadScheduler::IsScheduleRequired()) { auto scheduler = std::make_shared(); return scheduler->Schedule( - [=](Scheduler::shared){ + [=](Scheduler::shared) -> Disposable { try { return subscribe(observer); } catch (...) { @@ -60,6 +60,10 @@ namespace rxcpp std::function onCompleted; std::function onError; + virtual ~CreatedObserver() { + clear(); + } + virtual void OnNext(const T& element) { try @@ -122,6 +126,16 @@ namespace rxcpp protected: std::mutex lock; std::vector>> observers; + + virtual ~ObservableSubject() { + // putting this first means that the observers + // will be destructed outside the lock + std::vector>> empty; + + std::unique_lock guard(lock); + using std::swap; + swap(observers, empty); + } void RemoveObserver(std::shared_ptr> toRemove) { @@ -161,6 +175,7 @@ namespace rxcpp template class ObserverSubject : + public Observer, public Base { public: @@ -411,9 +426,6 @@ namespace rxcpp }); } - template - struct reveal_type {private: reveal_type();}; - template auto SelectMany( const std::shared_ptr>& source, @@ -551,6 +563,332 @@ namespace rxcpp }); } +#if RXCPP_USE_VARIADIC_TEMPLATES + namespace detail{ + template + struct CombineLatestSubscriber { + typedef typename SubscribeState::Latest Latest; + static void subscribe( + ComposableDisposable& cd, + const std::shared_ptr>& observer, + const std::shared_ptr& state, + const typename SubscribeState::Sources& sources) { + cd.Add(Subscribe( + std::get(sources), + // on next + [=](const typename std::tuple_element::type& element) + { + static bool pending = true; + auto local = state; + std::unique_lock guard(local->lock); + std::get(local->latest) = element; + if (pending) { + --local->pendingFirst; + pending = false; + } + if (local->pendingFirst == 0) { + Latest args = local->latest; + auto result = util::tuple_dispatch(local->selector, args); + ++state->pendingIssue; + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(result)); + } + --state->pendingIssue; + if (state->done && state->pendingIssue == 0) { + guard.unlock(); + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on completed + [=] + { + std::unique_lock guard(state->lock); + --state->pendingComplete; + if (state->pendingComplete == 0) { + state->done = true; + if (state->pendingIssue == 0) { + guard.unlock(); + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + CombineLatestSubscriber:: + subscribe(cd, observer, state, sources); + } + }; + template + struct CombineLatestSubscriber { + static void subscribe( + ComposableDisposable& , + const std::shared_ptr>& , + const std::shared_ptr& , + const typename SubscribeState::Sources& ) {} + }; + } + template + auto CombineLatest( + S selector, + const std::shared_ptr>&... source + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>...> Sources; + typedef std::tuple Latest; + struct State { + typedef Latest Latest; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : pendingFirst(SourcesSize::value) + , pendingIssue(0) + , pendingComplete(SourcesSize::value) + , done(false) + , selector(std::move(selector)) + {} + std::mutex lock; + size_t pendingFirst; + size_t pendingIssue; + size_t pendingComplete; + bool done; + S selector; + Latest latest; + }; + Sources sources(source...); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } + + namespace detail{ + template + struct ZipSubscriber { + typedef typename std::tuple_element::type::value_type Item; + typedef std::shared_ptr> ResultObserver; + struct Next + { + std::unique_lock& guard; + std::shared_ptr state; + const ResultObserver& observer; + const ComposableDisposable& cd; + explicit Next( + std::unique_lock& guard, + std::shared_ptr state, + const ResultObserver& observer, + const ComposableDisposable& cd) + : guard(guard) + , state(std::move(state)) + , observer(observer) + , cd(cd) { + } + template + void operator()(ZipQueue&... queue) { + // build array of bool that we can iterate to detect empty queues + bool empties[] = {queue.empty()...}; + if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { + // all queues have an item. + // + // copy front of each queue + auto args = std::make_tuple(queue.front()...); + + // cause side-effect of pop on each queue + std::make_tuple((queue.pop(), true)...); + + ++state->pending; + auto result = util::tuple_dispatch(state->selector, args); + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(result)); + } + --state->pending; + } + // build new array to check for any empty queue + bool post_empties[] = {queue.empty()...}; + if (state->completed && state->pending == 0 && + std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { + // at least one queue is empty and at least one of the sources has completed. + // it is time to stop. + + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnCompleted(); + cd.Dispose(); + } + } + }; + static void subscribe( + ComposableDisposable& cd, + const std::shared_ptr>& observer, + const std::shared_ptr& state, + const typename SubscribeState::Sources& sources) { + cd.Add(Subscribe( + std::get(sources), + // on next + [=](const Item& element) + { + std::unique_lock guard(state->lock); + std::get(state->queues).push(element); + Next next(guard, state, observer, cd); + util::tuple_dispatch(next, state->queues); + }, + // on completed + [=] + { + std::unique_lock guard(state->lock); + state->completed = true; + Next next(guard, state, observer, cd); + util::tuple_dispatch(next, state->queues); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + ZipSubscriber:: + subscribe(cd, observer, state, sources); + } + }; + template + struct ZipSubscriber { + static void subscribe( + ComposableDisposable& , + const std::shared_ptr>& , + const std::shared_ptr& , + const typename SubscribeState::Sources& ) {} + }; + } + template + auto Zip( + S selector, + const std::shared_ptr>&... source + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>...> Sources; + typedef std::tuple>>...> Queues; + struct State { + typedef Queues Queues; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : selector(std::move(selector)) + , pending(0) + , completed(false) + {} + std::mutex lock; + S selector; + size_t pending; + bool completed; + Queues queues; + }; + Sources sources(source...); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } + + namespace detail{ + template + struct MergeSubscriber { + typedef typename SubscribeState::result_type Item; + typedef std::shared_ptr> ResultObserver; + static void subscribe( + ComposableDisposable& cd, + const std::shared_ptr>& observer, + const std::shared_ptr& state, + const typename SubscribeState::Sources& sources) { + cd.Add(Subscribe( + std::get(sources), + // on next + [=](const Item& element) + { + observer->OnNext(element); + }, + // on completed + [=] + { + if (--state->pendingComplete == 0) { + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + MergeSubscriber:: + subscribe(cd, observer, state, sources); + } + }; + template + struct MergeSubscriber { + static void subscribe( + ComposableDisposable& , + const std::shared_ptr>& , + const std::shared_ptr& , + const typename SubscribeState::Sources& ) {} + }; + } + template + std::shared_ptr> Merge( + const std::shared_ptr>& firstSource, + const std::shared_ptr>&... otherSource + ) + { + typedef MergeSource result_type; + typedef decltype(std::make_tuple(firstSource, otherSource...)) Sources; + struct State { + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + State() + : pendingComplete(SourcesSize::value) + {} + std::atomic pendingComplete; + }; + Sources sources(firstSource, otherSource...); + // bug on osx prevents using make_shared + std::shared_ptr state(new State()); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES + template const std::shared_ptr> Where( const std::shared_ptr>& source, @@ -683,7 +1021,8 @@ namespace rxcpp [=](std::shared_ptr> observer) -> Disposable { - auto remaining = std::make_shared(n); + // keep count of remaining calls received OnNext and count of OnNext calls issued. + auto remaining = std::make_shared, std::atomic>>(n, n); ComposableDisposable cd; @@ -692,30 +1031,33 @@ namespace rxcpp // on next [=](const T& element) { - if (*remaining) - { + auto local = --std::get<0>(*remaining); + RXCPP_UNWIND_AUTO([&](){ + if (local >= 0){ + // all elements received + if (--std::get<1>(*remaining) == 0) { + // all elements passed on to observer. + observer->OnCompleted(); + cd.Dispose();}}}); + + if (local >= 0) { observer->OnNext(element); - if (--*remaining == 0) - { - observer->OnCompleted(); - cd.Dispose(); - } - } + } }, // on completed [=] { - if (*remaining) - { + if (std::get<1>(*remaining) == 0 && std::get<0>(*remaining) <= 0) { observer->OnCompleted(); + cd.Dispose(); } }, // on error [=](const std::exception_ptr& error) { - if (*remaining) - { + if (std::get<1>(*remaining) == 0 && std::get<0>(*remaining) <= 0) { observer->OnError(error); + cd.Dispose(); } })); return cd; @@ -898,53 +1240,35 @@ namespace rxcpp Scheduler::shared scheduler) { return CreateObservable( - [=](std::shared_ptr> observer) + [=](std::shared_ptr> observerArg) -> Disposable { - auto queue = std::make_shared(); - auto queueScheduler = queue->GetScheduler(); - + std::shared_ptr> observer( + new ScheduledObserver(scheduler, std::move(observerArg))); ComposableDisposable cd; - cd.Add(Disposable([=]{ - queue->Dispose(); - })); - - SharedDisposable sd; - cd.Add(sd); + cd.Add(*observer.get()); cd.Add(Subscribe( source, // on next [=](const T& element) { - sd.Set(queueScheduler->Schedule([=](Scheduler::shared){ - observer->OnNext(element); - return Disposable::Empty(); - })); - queue->RunOnScheduler(scheduler); + observer->OnNext(std::move(element)); + observer->EnsureActive(); }, // on completed [=] { - sd.Set(queueScheduler->Schedule( - [=](Scheduler::shared){ - observer->OnCompleted(); - return Disposable::Empty(); - } - )); - queue->RunOnScheduler(scheduler); + observer->OnCompleted(); + observer->EnsureActive(); }, // on error [=](const std::exception_ptr& error) { - queueScheduler->Schedule([=](Scheduler::shared){ - observer->OnError(error); - queue->Dispose(); - return Disposable::Empty(); - }); - queue->RunOnScheduler(scheduler); + observer->OnError(std::move(error)); + observer->EnsureActive(); })); return cd; }); diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 037e41e..7ecd850 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -13,27 +13,138 @@ namespace rxcpp // // schedulers - struct CurrentThreadScheduler : public LocalScheduler + struct CurrentThreadQueue { + typedef Scheduler::clock clock; + typedef Scheduler::Work Work; + struct QueueItem { + QueueItem(clock::time_point due, std::shared_ptr work) + : due(due) + , work(std::move(work)) + {} + clock::time_point due; + std::shared_ptr work; + }; + private: - CurrentThreadScheduler(const CurrentThreadScheduler&); + ~CurrentThreadQueue(); struct compare_work { - template - bool operator()(const T& work1, const T& work2) const { - return work1.first > work2.first; + bool operator()(const QueueItem& work1, const QueueItem& work2) const { + return work1.due > work2.due; } }; typedef std::priority_queue< - std::pair>, - std::vector>>, + QueueItem, + std::vector, compare_work > ScheduledWork; - RXCPP_THREAD_LOCAL static ScheduledWork* scheduledWork; + public: + struct ThreadLocalQueue { + Scheduler::shared scheduler; + ScheduledWork queue; + }; + + private: + RXCPP_THREAD_LOCAL static ThreadLocalQueue* threadLocalQueue; + + public: + + static Scheduler::shared GetScheduler() { + return !!threadLocalQueue ? threadLocalQueue->scheduler : Scheduler::shared(); + } + static bool empty() { + if (!threadLocalQueue) { + throw std::logic_error("this thread does not have a queue!"); + } + return threadLocalQueue->queue.empty(); + } + static ScheduledWork::const_reference top() { + if (!threadLocalQueue) { + throw std::logic_error("this thread does not have a queue!"); + } + return threadLocalQueue->queue.top(); + } + static void pop() { + if (!threadLocalQueue) { + throw std::logic_error("this thread does not have a queue!"); + } + threadLocalQueue->queue.pop(); + } + static void push(QueueItem item) { + if (!threadLocalQueue) { + throw std::logic_error("this thread does not have a queue!"); + } + threadLocalQueue->queue.push(std::move(item)); + } + static void EnsureQueue(Scheduler::shared scheduler) { + if (!!threadLocalQueue) { + throw std::logic_error("this thread already has a queue!"); + } + // create and publish new queue + threadLocalQueue = new ThreadLocalQueue(); + threadLocalQueue->scheduler = scheduler; + } + static std::unique_ptr CreateQueue(Scheduler::shared scheduler) { + std::unique_ptr result(new ThreadLocalQueue()); + result->scheduler = std::move(scheduler); + return result; + } + static void SetQueue(ThreadLocalQueue* queue) { + if (!!threadLocalQueue) { + throw std::logic_error("this thread already has a queue!"); + } + // create and publish new queue + threadLocalQueue = queue; + } + static void DestroyQueue(ThreadLocalQueue* queue) { + delete queue; + } + static void DestroyQueue() { + if (!threadLocalQueue) { + throw std::logic_error("this thread does not have a queue!"); + } + DestroyQueue(threadLocalQueue); + threadLocalQueue = nullptr; + } + }; + // static + RXCPP_SELECT_ANY RXCPP_THREAD_LOCAL CurrentThreadQueue::ThreadLocalQueue* CurrentThreadQueue::threadLocalQueue = nullptr; + + struct CurrentThreadScheduler : public LocalScheduler + { + private: + CurrentThreadScheduler(const CurrentThreadScheduler&); + + struct Derecurser : public LocalScheduler + { + private: + Derecurser(const Derecurser&); + public: + Derecurser() + { + } + virtual ~Derecurser() + { + } + + static bool IsScheduleRequired() { return false; } + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto cancelable = std::make_shared(std::move(work)); + + CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, cancelable)); + + return Disposable([cancelable]{ + *cancelable.get() = nullptr;}); + } + }; + public: CurrentThreadScheduler() { @@ -42,49 +153,50 @@ namespace rxcpp { } - static bool IsScheduleRequired() { return scheduledWork == nullptr; } + static bool IsScheduleRequired() { return !CurrentThreadQueue::GetScheduler(); } using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { - auto cancelable = std::make_shared(std::move(work)); - // check trampoline - if (!!scheduledWork) + auto localScheduler = CurrentThreadQueue::GetScheduler(); + // check ownership + if (!!localScheduler) { - scheduledWork->push(std::make_pair(dueTime, cancelable)); - return Disposable([=]{(*cancelable.get()) = nullptr;}); + // already has an owner - delegate + return localScheduler->Schedule(dueTime, std::move(work)); } - // create and publish new queue - scheduledWork = new ScheduledWork(); + // take ownership + + auto cancelable = std::make_shared(std::move(work)); + + CurrentThreadQueue::EnsureQueue(std::make_shared()); RXCPP_UNWIND_AUTO([]{ - delete scheduledWork; - scheduledWork = nullptr; + CurrentThreadQueue::DestroyQueue(); }); - scheduledWork->push(std::make_pair(dueTime, cancelable)); + CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); // loop until queue is empty for ( - auto dueTime = scheduledWork->top().first; + auto dueTime = CurrentThreadQueue::top().due; std::this_thread::sleep_until(dueTime), true; - dueTime = scheduledWork->top().first + dueTime = CurrentThreadQueue::top().due ) { // dispatch work - auto work = std::move(*scheduledWork->top().second.get()); - scheduledWork->pop(); + auto work = std::move(*CurrentThreadQueue::top().work.get()); + *CurrentThreadQueue::top().work.get() = nullptr; + CurrentThreadQueue::pop(); Do(work, get()); - - if (scheduledWork->empty()) {break;} + + if (CurrentThreadQueue::empty()) {break;} } return Disposable::Empty(); } }; - // static - RXCPP_SELECT_ANY RXCPP_THREAD_LOCAL CurrentThreadScheduler::ScheduledWork* CurrentThreadScheduler::scheduledWork = nullptr; struct ImmediateScheduler : public LocalScheduler { @@ -109,237 +221,248 @@ namespace rxcpp } }; - - class WorkQueue : public std::enable_shared_from_this + template + class ScheduledObserver : + public Observer, + public std::enable_shared_from_this> { - typedef LocalScheduler::Work Work; - typedef LocalScheduler::clock clock; - typedef std::pair Item; - typedef std::shared_ptr shared; + typedef std::function Action; - struct compare_work - { - template - bool operator()(const T& work1, const T& work2) const { - return work1.first > work2.first; - } - }; - + Scheduler::shared scheduler; + std::shared_ptr> observer; std::atomic trampoline; - std::priority_queue< - std::pair>, - std::vector>>, - compare_work > scheduledWork; + SharedDisposable sd; + mutable std::queue queue; mutable std::mutex lock; - mutable std::condition_variable wake; - mutable std::atomic exit; - - struct WorkQueueScheduler : public LocalScheduler - { - private: - WorkQueueScheduler(); - WorkQueueScheduler(const WorkQueueScheduler&); - - WorkQueue::shared queue; - - public: - WorkQueueScheduler(WorkQueue::shared queue) : queue(queue) - { - } - virtual ~WorkQueueScheduler() - { - } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto cancelable = std::make_shared(std::make_pair(get(), std::move(work))); - { - std::unique_lock guard(queue->lock); - queue->scheduledWork.push(std::make_pair(dueTime, cancelable)); - } - queue->wake.notify_one(); - auto local = queue; - return Disposable([local, cancelable]{ - std::unique_lock guard(local->lock); - cancelable.get()->second = nullptr;}); - } - }; public: - typedef std::function RunLoop; - typedef std::function Factory; - - WorkQueue() - : trampoline(0) - , exit(false) - { - } - - util::maybe EnsureThread(Factory& factory) + ScheduledObserver(Scheduler::shared scheduler, std::shared_ptr> observer) + : scheduler(std::move(scheduler)) + , observer(std::move(observer)) + , trampoline(0) { - util::maybe result; - std::unique_lock guard(lock); - RXCPP_UNWIND(unwindTrampoline, [&]{--trampoline;}); - if (++trampoline == 1) - { - auto local = shared_from_this(); - result.set(factory([local]{ - local->Run();})); - // trampoline lifetime is now owned by the thread - unwindTrampoline.dismiss(); - } - return result; } void Dispose() const { std::unique_lock guard(lock); - if (trampoline > 0) - { - exit = true; - wake.notify_one(); - } + while (!queue.empty()) {queue.pop();} + sd.Dispose(); } operator Disposable() const { - auto local = shared_from_this(); + auto local = this->shared_from_this(); return Disposable([local]{ local->Dispose(); }); } - Scheduler::shared GetScheduler() + + virtual void OnNext(const T& element) { - return std::make_shared(shared_from_this()); + std::unique_lock guard(lock); + auto local = this->shared_from_this(); + queue.push(Action([=](){ + local->observer->OnNext(std::move(element));})); } - void Run() + virtual void OnCompleted() { - auto keepAlive = shared_from_this(); - { - RXCPP_UNWIND_AUTO([&]{--trampoline;}); - - std::unique_lock guard(lock); - - while(!exit && !scheduledWork.empty()) - { - // wait until there is work - wake.wait(guard, [this]{ return this->exit || !this->scheduledWork.empty();}); - if (exit || scheduledWork.empty()) {break;} - - auto item = &scheduledWork.top(); - if (!item->second) {scheduledWork.pop(); continue;} - - // wait until the work is due - while (!exit && item->second && item->second.get()->first->Now() < item->first) - { - wake.wait_until(guard, item->first); - item = &scheduledWork.top(); - } - if (exit || scheduledWork.empty()) {break;} - if (!item->second) {scheduledWork.pop(); continue;} - - // dispatch work - auto work = std::move(item->second.get()->second); - auto scheduler = std::move(item->second.get()->first); - scheduledWork.pop(); - - RXCPP_UNWIND_AUTO([&]{guard.lock();}); - guard.unlock(); - LocalScheduler::Do(work, scheduler); - } - } - exit = false; + std::unique_lock guard(lock); + auto local = this->shared_from_this(); + queue.push(Action([=](){ + local->observer->OnCompleted();})); + } + virtual void OnError(const std::exception_ptr& error) + { + std::unique_lock guard(lock); + auto local = this->shared_from_this(); + queue.push(Action([=](){ + local->observer->OnError(std::move(error));})); } - Disposable RunOnScheduler(Scheduler::shared scheduler) + void EnsureActive() { RXCPP_UNWIND_AUTO([&]{--trampoline;}); if (++trampoline == 1) { // this is decremented when no further work is scheduled ++trampoline; - auto keepAlive = shared_from_this(); - return scheduler->Schedule( - [keepAlive, scheduler](Scheduler::shared){ - return keepAlive->RunOnSchedulerWork(scheduler);}); + auto keepAlive = this->shared_from_this(); + sd.Set(scheduler->Schedule( + [keepAlive](Scheduler::shared sched){ + return keepAlive->Run(sched);})); } - return Disposable::Empty(); } private: - Disposable RunOnSchedulerWork(Scheduler::shared scheduler) + Disposable Run(Scheduler::shared sched) { - auto keepAlive = shared_from_this(); + auto keepAlive = this->shared_from_this(); std::unique_lock guard(lock); - if(!exit && !scheduledWork.empty()) - { - auto& item = scheduledWork.top(); - - // wait until the work is due - if(!exit && item.second.get()->first->Now() < item.first) - { - return scheduler->Schedule( - item.first, - [keepAlive, scheduler](Scheduler::shared){ - return keepAlive->RunOnSchedulerWork(scheduler);}); - } + if(!queue.empty()) + { + auto& item = queue.front(); - if(!exit) - { - // dispatch work - auto work = std::move(item.second.get()->second); - auto scheduler = std::move(item.second.get()->first); - scheduledWork.pop(); + // dispatch action + auto action = std::move(item); + item = nullptr; + queue.pop(); - RXCPP_UNWIND_AUTO([&]{guard.lock();}); - guard.unlock(); - LocalScheduler::Do(work, scheduler); - } + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + action(); } - if(!exit && !scheduledWork.empty()) + if(!queue.empty()) { - return scheduler->Schedule( - [keepAlive, scheduler](Scheduler::shared){ - return keepAlive->RunOnSchedulerWork(scheduler);}); + guard.unlock(); + sd.Set(sched->Schedule( + [keepAlive](Scheduler::shared sched){ + return keepAlive->Run(sched);})); + return Disposable::Empty(); } // only decrement when no further work is scheduled --trampoline; - exit = false; return Disposable::Empty(); } }; - struct EventLoopScheduler : public LocalScheduler { private: EventLoopScheduler(const EventLoopScheduler&); + + struct Derecurser : public std::enable_shared_from_this + { + private: + Derecurser(const Derecurser&); + + std::atomic trampoline; + mutable std::mutex lock; + mutable std::condition_variable wake; + mutable std::atomic exit; + CurrentThreadQueue::ThreadLocalQueue* queue; + + public: + Derecurser() + : trampoline(0) + , exit(false) + { + } + virtual ~Derecurser() + { + } + + typedef std::function RunLoop; + typedef std::function Factory; + + static bool IsScheduleRequired() { return false; } - std::shared_ptr queue; - Scheduler::shared scheduler; + typedef std::tuple, Disposable> EnsureThreadResult; + EnsureThreadResult EnsureThread(Factory& factory, Scheduler::shared owner, clock::time_point dueTime, Work work) + { + EnsureThreadResult result(util::maybe(), Disposable::Empty()); + + auto cancelable = std::make_shared(std::move(work)); + + std::unique_lock guard(lock); + RXCPP_UNWIND(unwindTrampoline, [&]{--trampoline;}); + + if (++trampoline == 1) + { + RXCPP_UNWIND(unwindQueue, [&](){ + CurrentThreadQueue::DestroyQueue(queue); queue = nullptr;}); + queue = CurrentThreadQueue::CreateQueue(owner).release(); + + std::get<1>(result) = Disposable([cancelable]{ + *cancelable.get() = nullptr;}); + queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); + + auto local = std::static_pointer_cast(shared_from_this()); + auto localQueue = queue; + std::get<0>(result).set(factory([local, localQueue]{ + local->Run(localQueue);})); + + // trampoline and queue lifetime is now owned by the thread + unwindTrampoline.dismiss(); + unwindQueue.dismiss(); + } + else + { + std::get<1>(result) = Disposable([cancelable]{ + *cancelable.get() = nullptr;}); + queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); + wake.notify_one(); + } + return std::move(result); + } + + private: + void Run(CurrentThreadQueue::ThreadLocalQueue* queue) { + auto keepAlive = shared_from_this(); + { + RXCPP_UNWIND_AUTO([&]{--trampoline;}); + + std::unique_lock guard(lock); + + CurrentThreadQueue::SetQueue(queue); + RXCPP_UNWIND(unwindQueue, [&](){ + CurrentThreadQueue::DestroyQueue(); + queue = nullptr;}); + + while(!exit && (!CurrentThreadQueue::empty() || trampoline > 1)) + { + if (CurrentThreadQueue::empty()) { + wake.wait(guard, [&](){ + return exit || !CurrentThreadQueue::empty() || trampoline == 1;}); + continue; + } + + auto item = &CurrentThreadQueue::top(); + if (!item->work || !*item->work.get()) {CurrentThreadQueue::pop(); continue;} + + // wait until the work is due + if (!exit && queue->scheduler->Now() < item->due) + { + wake.wait_until(guard, item->due); + continue; + } + if (exit || CurrentThreadQueue::empty()) {break;} + if (!item->work || !*item->work.get()) {CurrentThreadQueue::pop(); continue;} + + // dispatch work + auto work = std::move(*item->work.get()); + *item->work.get() = nullptr; + CurrentThreadQueue::pop(); + + RXCPP_UNWIND_AUTO([&]{guard.lock();}); + guard.unlock(); + LocalScheduler::Do(work, queue->scheduler); + } + } + exit = false; + } + }; + std::thread worker; - WorkQueue::Factory factory; - + Derecurser::Factory factory; + std::shared_ptr derecurser; + public: EventLoopScheduler() - : queue(std::make_shared()) - , scheduler(queue->GetScheduler()) + : derecurser(std::make_shared()) { - auto local = queue; - factory = [local] (WorkQueue::RunLoop rl) -> std::thread { + auto local = derecurser; + factory = [local] (Derecurser::RunLoop rl) -> std::thread { return std::thread([local, rl]{rl();}); }; } template EventLoopScheduler(Factory factoryarg) - : queue(std::make_shared()) - , scheduler(queue->GetScheduler()) + : derecurser(std::make_shared()) + , factory(std::move(factoryarg)) { - auto local = queue; - factory = std::move(factoryarg); } virtual ~EventLoopScheduler() { @@ -347,22 +470,22 @@ namespace rxcpp worker.detach(); } } + + static bool IsScheduleRequired() { return !CurrentThreadQueue::GetScheduler(); } using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { - Disposable result = scheduler->Schedule(dueTime, std::move(work)); - - auto maybeThread = queue->EnsureThread(factory); - if (maybeThread) + auto maybeThread = derecurser->EnsureThread(factory, this->shared_from_this(), dueTime, std::move(work)); + if (std::get<0>(maybeThread)) { if (worker.joinable()) { worker.join(); } - worker = std::move(*maybeThread.get()); + worker = std::move(*std::get<0>(maybeThread).get()); } - return std::move(result); + return std::move(std::get<1>(maybeThread)); } }; diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 144fbc6..9a0eb29 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -136,6 +136,62 @@ namespace rxcpp { namespace util { }; + template + struct reveal_type {private: reveal_type();}; + +#if RXCPP_USE_VARIADIC_TEMPLATES + template + struct tuple_indices; + template <> + struct tuple_indices<-1> { // for an empty std::tuple<> there is no entry + typedef tuple_indices<> type; + }; + template + struct tuple_indices<0, Indices...> { // stop the recursion when 0 is reached + typedef tuple_indices<0, Indices...> type; + }; + template + struct tuple_indices { // recursively build a sequence of indices + typedef typename tuple_indices::type type; + }; + + template + struct make_tuple_indices { + typedef typename tuple_indices::value - 1>::type type; + }; + + namespace detail { + template + struct tuple_dispatch; + template + struct tuple_dispatch> { + template + static + auto call(F&& f, T&& t) + -> decltype (std::forward(f)(std::get(std::forward(t))...)) { + return std::forward(f)(std::get(std::forward(t))...); + } + };} + + template + auto tuple_dispatch(F&& f, T&& t) + -> decltype(detail::tuple_dispatch::type>::type>::call(std::forward(f), std::forward(t))) { + return detail::tuple_dispatch::type>::type>::call(std::forward(f), std::forward(t)); + } + + struct as_tuple { + template + auto operator()(AsTupleNext... x) + -> decltype(std::make_tuple(std::move(x)...)) const { + return std::make_tuple(std::move(x)...);} + }; +#endif //RXCPP_USE_VARIADIC_TEMPLATES + + struct pass_through { + template + X operator()(X x) const {return std::move(x);} + }; + template class unwinder { diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 31b932b..a2cb3fc 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -9,6 +9,8 @@ #if defined(WINDOWS) || defined(WIN32) || defined(_WIN32) +#pragma comment(lib, "user32.lib") + #define NOMINMAX #include diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index b5a75cb..c76a21c 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -14,13 +14,13 @@ namespace rxcpp protected: Obj obj; - struct pass_through { - template - X operator()(X x) const {return std::move(x);} - }; public: typedef T item_type; typedef Obj observable_type; + typedef util::pass_through pass_through; +#if RXCPP_USE_VARIADIC_TEMPLATES + typedef util::as_tuple as_tuple; +#endif //RXCPP_USE_VARIADIC_TEMPLATES BinderBase(Obj obj) : obj(std::move(obj)) { @@ -37,6 +37,9 @@ namespace rxcpp typedef BinderBase base; typedef typename base::item_type item_type; typedef typename base::pass_through pass_through; +#if RXCPP_USE_VARIADIC_TEMPLATES + typedef typename base::as_tuple as_tuple; +#endif //RXCPP_USE_VARIADIC_TEMPLATES using base::obj; public: static const bool is_item_observable = false; @@ -52,6 +55,9 @@ namespace rxcpp typedef BinderBase base; typedef typename base::item_type item_type; typedef typename base::pass_through pass_through; +#if RXCPP_USE_VARIADIC_TEMPLATES + typedef typename base::as_tuple as_tuple; +#endif //RXCPP_USE_VARIADIC_TEMPLATES using base::obj; public: static const bool is_item_observable = true; @@ -88,6 +94,9 @@ namespace rxcpp is_observable::type>::value> base; typedef typename base::item_type item_type; typedef typename base::pass_through pass_through; +#if RXCPP_USE_VARIADIC_TEMPLATES + typedef typename base::as_tuple as_tuple; +#endif //RXCPP_USE_VARIADIC_TEMPLATES using base::obj; public: @@ -99,6 +108,33 @@ namespace rxcpp auto select(S selector) -> decltype(from(Select(obj, selector))) { return from(Select(obj, selector)); } +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto merge(const MergeSource&... source) + -> decltype(from(Merge(obj, source...))) { + return from(Merge(obj, source...)); + } + template + auto zip(S selector, const ZipSource&... source) + -> decltype(from(Zip(selector, obj, source...))) { + return from(Zip(selector, obj, source...)); + } + template + auto zip(const Zip1Source&... source) + -> decltype(from(Zip(as_tuple(), obj, source...))) { + return from(Zip(as_tuple(), obj, source...)); + } + template + auto combine_latest(S selector, const CombineLSource&... source) + -> decltype(from(CombineLatest(selector, obj, source...))) { + return from(CombineLatest(selector, obj, source...)); + } + template + auto combine_latest(const CombineL1Source&... source) + -> decltype(from(CombineLatest(as_tuple(), obj, source...))) { + return from(CombineLatest(as_tuple(), obj, source...)); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES template auto where(P predicate) -> decltype(from(Where(obj, predicate))) { return from(Where(obj, predicate)); @@ -177,10 +213,10 @@ namespace rxcpp return result; } #if RXCPP_USE_VARIADIC_TEMPLATES - template - auto chain(Arg&& ...arg) - -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)...))) { - return from(rxcpp_chain(Tag(), obj, std::forward(arg)...)); + template + auto chain(ChainArg&&... arg) + -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)...))) { + return from(rxcpp_chain(Tag(), obj, std::forward(arg)...)); } #endif }; diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 01f08c8..b282fbd 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -32,6 +32,164 @@ void PrintPrimes(int n) }); } +void Combine(int n) +{ +#if RXCPP_USE_VARIADIC_TEMPLATES + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); + + auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .where(IsPrime) + .select([](int prime){this_thread::yield(); return prime;}) + .publish(); + + auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers + rxcpp::from(values2) + .subscribe_on(input2) + .where(IsPrime) + .select([](int prime){this_thread::yield(); return prime;}) + .combine_latest(s1) + .take(n) + .observe_on(output) + .for_each( + [](tuple p) { + cout << get<0>(p) << " =combined=> " << get<1>(p) << endl; + }); +#else + (void)n; +#endif //RXCPP_USE_VARIADIC_TEMPLATES +} + +struct Count { + Count() : nexts(0), completions(0), errors(0), disposals(0) {} + std::atomic nexts; + std::atomic completions; + std::atomic errors; + std::atomic disposals; +}; +template +std::shared_ptr> Record( + const std::shared_ptr>& source, + Count* count + ) +{ + return rxcpp::CreateObservable( + [=](std::shared_ptr> observer) + { + rxcpp::ComposableDisposable cd; + cd.Add(rxcpp::Disposable([=](){ + ++count->disposals;})); + cd.Add(rxcpp::Subscribe( + source, + // on next + [=](T element) + { + ++count->nexts; + observer->OnNext(std::move(element)); + }, + // on completed + [=] + { + ++count->completions; + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + ++count->errors; + observer->OnError(error); + })); + return cd; + }); +} +struct record {}; +template +rxcpp::Binder>> rxcpp_chain(record&&, const std::shared_ptr>& source, Count* count) { + return rxcpp::from(Record(source, count)); +} + +template +void Zip(int n) +{ +#if RXCPP_USE_VARIADIC_TEMPLATES + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); + + Count s1count, s2count, zipcount, takecount, outputcount; + + auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .where(IsPrime) + .template chain(&s1count) + .select([](int prime){this_thread::yield(); return prime;}) + .publish(); + + auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers + rxcpp::from(values2) + .subscribe_on(input2) + .where(IsPrime) + .template chain(&s2count) + .select([](int prime){this_thread::yield(); return prime;}) + .zip(s1) + .template chain(&zipcount) + .take(n) + .template chain(&takecount) + .observe_on(output) + .template chain(&outputcount) + .for_each( + [](tuple p) { + cout << get<0>(p) << " =zipped=> " << get<1>(p) << endl; + }); + + cout << "location: nexts, completions, errors, disposals" << endl; + cout << "s1count:" << s1count.nexts << ", " << s1count.completions << ", " << s1count.errors << ", " << s1count.disposals << endl; + cout << "s2count:" << s2count.nexts << ", " << s2count.completions << ", " << s2count.errors << ", " << s2count.disposals << endl; + cout << "zipcount:" << zipcount.nexts << ", " << zipcount.completions << ", " << zipcount.errors << ", " << zipcount.disposals << endl; + cout << "takecount:" << takecount.nexts << ", " << takecount.completions << ", " << takecount.errors << ", " << takecount.disposals << endl; + cout << "outputcount:" << outputcount.nexts << ", " << outputcount.completions << ", " << outputcount.errors << ", " << outputcount.disposals << endl; +#else + (void)n; +#endif //RXCPP_USE_VARIADIC_TEMPLATES +} + +void Merge(int n) +{ +#if RXCPP_USE_VARIADIC_TEMPLATES + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); + + cout << "merge==> : " << endl; + + auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .where(IsPrime) + .select([](int prime1) {this_thread::yield(); return std::make_tuple("1: ", prime1);}) + .publish(); + + auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers + rxcpp::from(values2) + .subscribe_on(input2) + .where(IsPrime) + .select([](int prime2) {this_thread::yield(); return std::make_tuple("2: ", prime2);}) + .merge(s1) + .take(n) + .observe_on(output) + .for_each( + [](tuple p) { + cout << get<0>(p) << get<1>(p) << endl; + }); +#else + (void)n; +#endif //RXCPP_USE_VARIADIC_TEMPLATES +} + std::shared_ptr> Data( string filename, rxcpp::Scheduler::shared scheduler = std::make_shared() @@ -135,12 +293,38 @@ void run() }); } +template +void innerScheduler() { + auto outer = std::make_shared(); + rxcpp::Scheduler::shared inner; + outer->Schedule([&](rxcpp::Scheduler::shared s){ + inner = s; return rxcpp::Disposable::Empty();}); + while(!inner); + inner->Schedule([&](rxcpp::Scheduler::shared s){ + inner = nullptr; return rxcpp::Disposable::Empty();}); + while(!!inner); + cout << "innerScheduler test succeeded" << endl; +} + int main(int argc, char* argv[]) { - PrintPrimes(20); - try { + PrintPrimes(20); + cout << "Zip Immediate" << endl; + Zip(20); + cout << "Zip Current" << endl; + Zip(20); + cout << "Zip EventLoop" << endl; + Zip(20); + Combine(20); + Merge(20); + + innerScheduler(); + innerScheduler(); + innerScheduler(); + run(); + } catch (exception& e) { cerr << "exception: " << e.what() << endl; } -- GitLab From 8fd8c0e79ca0030b95e78e8f776e291872da9515 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Mar 2013 22:37:12 -0700 Subject: [PATCH 031/782] adds to_vector and to_list and fixes select_many --- Rx/CPP/src/cpprx/rx-base.hpp | 77 ++++++++++++++++ Rx/CPP/src/cpprx/rx-includes.hpp | 1 + Rx/CPP/src/cpprx/rx-operators.hpp | 77 +++++++++------- Rx/CPP/src/cpprx/rx-util.hpp | 148 +++++++++++++++++++++++++++++- Rx/CPP/src/cpprx/rx-windows.hpp | 3 +- Rx/CPP/src/cpprx/rx.hpp | 62 +++++++------ Rx/CPP/testbench/testbench.cpp | 125 +++++++++++-------------- 7 files changed, 360 insertions(+), 133 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 6182d0c..970c3c0 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -293,6 +293,44 @@ namespace rxcpp } }; + template + class TupleDispatch { + Target target; + public: + TupleDispatch(Target target) : target(std::move(target)) { + } + template + auto operator()(const Tuple& tuple) -> decltype(util::tuple_dispatch(target, tuple)) { + return util::tuple_dispatch(target, tuple);} + }; + + template + TupleDispatch MakeTupleDispatch(Target&& target) { + return TupleDispatch(std::forward(target));} + + template + auto DispatchTuple(Tuple&& tuple, Target&& target) -> + decltype(util::tuple_dispatch(std::forward(target), std::forward(tuple))) { + return util::tuple_dispatch(std::forward(target), std::forward(tuple));} + +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto ConcatTuple(Lhs&& lhs, Rhs&& rhs) -> + decltype(util::tuple_concat(std::forward(lhs), std::forward(rhs))) { + return util::tuple_concat(std::forward(lhs), std::forward(rhs));} + + template + auto TieTuple(T&& t) -> + decltype(util::tuple_tie(std::forward(t))) { + return util::tuple_tie(std::forward(t));} +#endif //RXCPP_USE_VARIADIC_TEMPLATES + + template + class Subject; + + template + class GroupedSubject; + template T item(const std::shared_ptr>&); @@ -305,9 +343,15 @@ namespace rxcpp template struct is_observable>> {static const bool value = true;}; + template + struct is_observable>> {static const bool value = true;}; + template struct is_observable>> {static const bool value = true;}; + template + struct is_observable>> {static const bool value = true;}; + template struct observable_item; @@ -316,5 +360,38 @@ namespace rxcpp template struct observable_item>> {typedef T type;}; + + template + struct observable_observer; + + template + struct observable_observer>> {typedef std::shared_ptr> type;}; + + template + struct observable_observer>> {typedef std::shared_ptr> type;}; + + template + struct observer_item; + + template + struct observer_item>> {typedef T type;}; + + template + struct subject_item; + + template + struct subject_item>> {typedef T type;}; + + template + struct subject_observer; + + template + struct subject_observer>> {typedef std::shared_ptr> type;}; + + template + struct subject_observable; + + template + struct subject_observable>> {typedef std::shared_ptr> type;}; } #endif diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index e0574aa..8c861f0 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index a2e8b3c..8ee85e1 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -387,7 +387,8 @@ namespace rxcpp wake.wait(guard, [&]{return done;}); } - if (error != std::exception_ptr()) {std::rethrow_exception(error);} + if (error != std::exception_ptr()) { + std::rethrow_exception(error);} } ////////////////////////////////////////////////////////////////////// @@ -432,13 +433,13 @@ namespace rxcpp CS collectionSelector, RS resultSelector) -> const std::shared_ptr::type>::type&)>::type>> { typedef typename std::result_of::type C; typedef typename observable_item::type CI; - typedef typename std::result_of::type U; + typedef typename std::result_of::type U; return CreateObservable( [=](std::shared_ptr> observer) @@ -464,7 +465,7 @@ namespace rxcpp cd.Add(Subscribe( source, // on next - [=](const T& element) + [=](const T& sourceElement) { bool cancel = false; { @@ -474,11 +475,11 @@ namespace rxcpp } if (!cancel) { try { - auto collection = collectionSelector(element); + auto collection = collectionSelector(sourceElement); cd.Add(Subscribe( collection, // on next - [=](const CI& element) + [=](const CI& collectionElement) { bool cancel = false; { @@ -487,7 +488,7 @@ namespace rxcpp } try { if (!cancel) { - auto result = resultSelector(element); + auto result = resultSelector(sourceElement, collectionElement); observer->OnNext(std::move(result)); } } catch (...) { @@ -940,21 +941,11 @@ namespace rxcpp return CreateObservable( [=](std::shared_ptr> observer) { - typedef std::function OnNext; - typedef std::function OnCompleted; - typedef std::function OnError; - - struct GroupValue - { - OnNext onNext; - OnCompleted onCompleted; - OnError onError; - }; - typedef std::map Groups; + typedef std::map>, L> Groups; struct State { - State(L less) : groups(std::move(less)) {} + explicit State(L less) : groups(std::move(less)) {} std::mutex lock; Groups groups; }; @@ -970,18 +961,11 @@ namespace rxcpp typename Groups::iterator groupIt; bool newGroup = false; - GroupValue value; - value.onNext = [keySubject](Value v){ - keySubject->OnNext(std::move(v));}; - value.onCompleted = [keySubject](){ - keySubject->OnCompleted();}; - value.onError = [keySubject](const std::exception_ptr& e){ - keySubject->OnError(std::move(e));}; { std::unique_lock guard(state->lock); - std::tie(groupIt, newGroup) = state->groups.insert(std::make_pair( - key,std::move(value)) + std::tie(groupIt, newGroup) = state->groups.insert( + std::make_pair(key,keySubject) ); } @@ -990,13 +974,14 @@ namespace rxcpp LocalGroupObservable nextGroup(std::move(keySubject)); observer->OnNext(nextGroup); } - groupIt->second.onNext(valueSelector(element)); + auto result = valueSelector(element); + groupIt->second->OnNext(std::move(result)); }, // on completed [=] { for(auto& group : state->groups) { - group.second.onCompleted(); + group.second->OnCompleted(); } observer->OnCompleted(); }, @@ -1004,7 +989,7 @@ namespace rxcpp [=](const std::exception_ptr& error) { for(auto& group : state->groups) { - group.second.onError(error); + group.second->OnError(error); } observer->OnError(error); }); @@ -1064,6 +1049,36 @@ namespace rxcpp }); } + template + const std::shared_ptr> ToStdCollection( + const std::shared_ptr>& source + ) + { + typedef typename StdCollection::value_type Value; + return CreateObservable( + [=](std::shared_ptr> observer) + { + auto stdCollection = std::make_shared(); + return Subscribe( + source, + // on next + [=](const Value& element) + { + stdCollection->insert(stdCollection->end(), element); + }, + // on completed + [=] + { + observer->OnNext(std::move(*stdCollection.get())); + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } ////////////////////////////////////////////////////////////////////// // diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 9a0eb29..d869577 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -179,19 +179,165 @@ namespace rxcpp { namespace util { return detail::tuple_dispatch::type>::type>::call(std::forward(f), std::forward(t)); } + namespace detail { + template + struct tuple_concat; + template + struct tuple_concat, tuple_indices> { + template + static + auto concatenate(LhsTuple&& lhs, RhsTuple&& rhs) + -> decltype (std::tuple< + typename std::tuple_element::type>::type..., + typename std::tuple_element::type>::type...>( + std::get(std::forward(lhs))..., + std::get(std::forward(rhs))...)) { + return std::tuple< + typename std::tuple_element::type>::type..., + typename std::tuple_element::type>::type...>( + std::get(std::forward(lhs))..., + std::get(std::forward(rhs))...); + } + };} + + template + auto tuple_concat(LhsTuple&& lhs, RhsTuple&& rhs) + -> decltype(detail::tuple_concat< + typename make_tuple_indices::type>::type, + typename make_tuple_indices::type>::type>:: + concatenate(std::forward(lhs), std::forward(rhs))) { + return detail::tuple_concat< + typename make_tuple_indices::type>::type, + typename make_tuple_indices::type>::type>:: + concatenate(std::forward(lhs), std::forward(rhs)); + } + + namespace detail { + template + struct tuple_tie; + template + struct tuple_tie> { + template + static + auto tie(T&& t) + -> decltype (std::tie(std::get(std::forward(t))...)) { + return std::tie(std::get(std::forward(t))...); + } + };} + + template + auto tuple_tie(T&& t) + -> decltype(detail::tuple_tie::type>::type>::tie(std::forward(t))) { + return detail::tuple_tie::type>::type>::tie(std::forward(t)); + } + struct as_tuple { template auto operator()(AsTupleNext... x) - -> decltype(std::make_tuple(std::move(x)...)) const { + -> decltype(std::make_tuple(std::move(x)...)) { + return std::make_tuple(std::move(x)...);} + template + auto operator()(AsTupleNext... x) const + -> decltype(std::make_tuple(std::move(x)...)) { return std::make_tuple(std::move(x)...);} }; +#else + namespace detail { + template + struct tuple_dispatch; + template<> + struct tuple_dispatch<0> { + template + static auto call(F&& f, T&& ) + -> decltype (std::forward(f)()) { + return std::forward(f)();} + }; + template<> + struct tuple_dispatch<1> { + template + static auto call(F&& f, T&& t) + -> decltype (std::forward(f)(std::get<0>(std::forward(t)))) { + return std::forward(f)(std::get<0>(std::forward(t)));} + }; + template<> + struct tuple_dispatch<2> { + template + static auto call(F&& f, T&& t) + -> decltype (std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)))) { + return std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)));} + }; + template<> + struct tuple_dispatch<3> { + template + static auto call(F&& f, T&& t) + -> decltype (std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)), + std::get<2>(std::forward(t)))) { + return std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)), + std::get<2>(std::forward(t)));} + }; + template<> + struct tuple_dispatch<4> { + template + static auto call(F&& f, T&& t) + -> decltype (std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)), + std::get<2>(std::forward(t)), + std::get<3>(std::forward(t)))) { + return std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)), + std::get<2>(std::forward(t)), + std::get<3>(std::forward(t)));} + }; + template<> + struct tuple_dispatch<5> { + template + static auto call(F&& f, T&& t) + -> decltype (std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)), + std::get<2>(std::forward(t)), + std::get<3>(std::forward(t)), + std::get<4>(std::forward(t)))) { + return std::forward(f)( + std::get<0>(std::forward(t)), + std::get<1>(std::forward(t)), + std::get<2>(std::forward(t)), + std::get<3>(std::forward(t)), + std::get<4>(std::forward(t)));} + }; + } + + template + auto tuple_dispatch(F&& f, T&& t) + -> decltype(detail::tuple_dispatch::type>::value>::call(std::forward(f), std::forward(t))) { + return detail::tuple_dispatch::type>::value>::call(std::forward(f), std::forward(t)); + } #endif //RXCPP_USE_VARIADIC_TEMPLATES struct pass_through { + template + X operator()(X x) {return std::move(x);} template X operator()(X x) const {return std::move(x);} }; + struct pass_through_second { + template + Y operator()(X , Y y) {return std::move(y);} + template + Y operator()(X , Y y) const {return std::move(y);} + }; + template class unwinder { diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index a2cb3fc..7d64a1b 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -141,8 +141,7 @@ namespace rxcpp { namespace win32 { wndclass.hInstance = NULL; wndclass.lpszClassName = className(); - if (!RegisterClassW(&wndclass)) - throw std::exception("failed to register windows class"); + RegisterClassW(&wndclass); std::unique_ptr that(new WindowClass); that->queue = queue; diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index c76a21c..a51f3ef 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -17,10 +17,6 @@ namespace rxcpp public: typedef T item_type; typedef Obj observable_type; - typedef util::pass_through pass_through; -#if RXCPP_USE_VARIADIC_TEMPLATES - typedef util::as_tuple as_tuple; -#endif //RXCPP_USE_VARIADIC_TEMPLATES BinderBase(Obj obj) : obj(std::move(obj)) { @@ -36,10 +32,6 @@ namespace rxcpp protected: typedef BinderBase base; typedef typename base::item_type item_type; - typedef typename base::pass_through pass_through; -#if RXCPP_USE_VARIADIC_TEMPLATES - typedef typename base::as_tuple as_tuple; -#endif //RXCPP_USE_VARIADIC_TEMPLATES using base::obj; public: static const bool is_item_observable = false; @@ -54,10 +46,6 @@ namespace rxcpp protected: typedef BinderBase base; typedef typename base::item_type item_type; - typedef typename base::pass_through pass_through; -#if RXCPP_USE_VARIADIC_TEMPLATES - typedef typename base::as_tuple as_tuple; -#endif //RXCPP_USE_VARIADIC_TEMPLATES using base::obj; public: static const bool is_item_observable = true; @@ -67,18 +55,18 @@ namespace rxcpp } auto select_many() - -> decltype(from(SelectMany(obj, pass_through(), pass_through()))) { - return from(SelectMany(obj, pass_through(), pass_through())); + -> decltype(from(SelectMany(obj, util::pass_through(), util::pass_through_second()))) { + return from(SelectMany(obj, util::pass_through(), util::pass_through_second())); } template auto select_many(CS collectionSelector) - -> decltype(from(SelectMany(obj, std::move(collectionSelector), pass_through()))) { - return from(SelectMany(obj, std::move(collectionSelector), pass_through())); + -> decltype(from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second()))) { + return from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second())); } template auto select_many(CS collectionSelector, RS resultSelector) - -> decltype(from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector)))) { - return from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector))); + -> decltype(from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector)))) { + return from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector))); } }; @@ -93,10 +81,6 @@ namespace rxcpp Obj, is_observable::type>::value> base; typedef typename base::item_type item_type; - typedef typename base::pass_through pass_through; -#if RXCPP_USE_VARIADIC_TEMPLATES - typedef typename base::as_tuple as_tuple; -#endif //RXCPP_USE_VARIADIC_TEMPLATES using base::obj; public: @@ -121,8 +105,8 @@ namespace rxcpp } template auto zip(const Zip1Source&... source) - -> decltype(from(Zip(as_tuple(), obj, source...))) { - return from(Zip(as_tuple(), obj, source...)); + -> decltype(from(Zip(util::as_tuple(), obj, source...))) { + return from(Zip(util::as_tuple(), obj, source...)); } template auto combine_latest(S selector, const CombineLSource&... source) @@ -131,8 +115,8 @@ namespace rxcpp } template auto combine_latest(const CombineL1Source&... source) - -> decltype(from(CombineLatest(as_tuple(), obj, source...))) { - return from(CombineLatest(as_tuple(), obj, source...)); + -> decltype(from(CombineLatest(util::as_tuple(), obj, source...))) { + return from(CombineLatest(util::as_tuple(), obj, source...)); } #endif //RXCPP_USE_VARIADIC_TEMPLATES template @@ -145,15 +129,15 @@ namespace rxcpp template auto group_by( KS keySelector) - -> decltype(from(GroupBy(obj, keySelector, pass_through(), std::less()))) { - return from(GroupBy(obj, keySelector, pass_through(), std::less())); + -> decltype(from(GroupBy(obj, keySelector, util::pass_through(), std::less()))) { + return from(GroupBy(obj, keySelector, util::pass_through(), std::less())); } template auto group_by( KS keySelector, VS valueSelector) -> decltype(from(GroupBy(obj, keySelector, valueSelector, std::less()))) { - return from(GroupBy(obj, keySelector, valueSelector, std::less())); + return from(GroupBy(obj, keySelector, valueSelector, std::less())); } template auto group_by( @@ -161,12 +145,30 @@ namespace rxcpp VS valueSelector, L less) -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { - return from(GroupBy(obj, keySelector, valueSelector, less)); + return from(GroupBy(obj, keySelector, valueSelector, less)); } template auto take(Integral n) -> decltype(from(Take(obj, n))) { return from(Take(obj, n)); } + templateclass Allocator> + auto to_vector() + -> decltype(from(ToStdCollection>>(obj))) { + return from(ToStdCollection>>(obj)); + } + auto to_vector() + -> decltype(from(ToStdCollection>(obj))) { + return from(ToStdCollection>(obj)); + } + templateclass Allocator> + auto to_list() + -> decltype(from(ToStdCollection>>(obj))) { + return from(ToStdCollection>>(obj)); + } + auto to_list() + -> decltype(from(ToStdCollection>(obj))) { + return from(ToStdCollection>(obj)); + } auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { return from(Delay(obj, due, scheduler)); } diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index b282fbd..c1913ae 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -26,10 +26,10 @@ void PrintPrimes(int n) .where(IsPrime) .select([](int x) { return std::make_pair(x, x*x); }) .take(n) - .subscribe( - [](pair p) { - cout << p.first << " =square=> " << p.second << endl; - }); + .subscribe(rxcpp::MakeTupleDispatch( + [](int p, int s) { + cout << p << " =square=> " << s << endl; + })); } void Combine(int n) @@ -54,10 +54,10 @@ void Combine(int n) .combine_latest(s1) .take(n) .observe_on(output) - .for_each( - [](tuple p) { - cout << get<0>(p) << " =combined=> " << get<1>(p) << endl; - }); + .for_each(rxcpp::MakeTupleDispatch( + [](int p2, int p1) { + cout << p2 << " =combined=> " << p1 << endl; + })); #else (void)n; #endif //RXCPP_USE_VARIADIC_TEMPLATES @@ -141,10 +141,10 @@ void Zip(int n) .template chain(&takecount) .observe_on(output) .template chain(&outputcount) - .for_each( - [](tuple p) { - cout << get<0>(p) << " =zipped=> " << get<1>(p) << endl; - }); + .for_each(rxcpp::MakeTupleDispatch( + [](int p2, int p1) { + cout << p2 << " =zipped=> " << p1 << endl; + })); cout << "location: nexts, completions, errors, disposals" << endl; cout << "s1count:" << s1count.nexts << ", " << s1count.completions << ", " << s1count.errors << ", " << s1count.disposals << endl; @@ -181,10 +181,10 @@ void Merge(int n) .merge(s1) .take(n) .observe_on(output) - .for_each( - [](tuple p) { - cout << get<0>(p) << get<1>(p) << endl; - }); + .for_each(rxcpp::MakeTupleDispatch( + [](const char* s, int p) { + cout << s << p << endl; + })); #else (void)n; #endif //RXCPP_USE_VARIADIC_TEMPLATES @@ -229,68 +229,55 @@ void run() .group_by([](const item& i) { return i.args;} ) - .select([=](const std::shared_ptr> & gob){ - return std::make_pair( - gob->Key(), // keep args key - rxcpp::from(gob) + // flatten concurrencies in the same args + .select_many( + [](const std::shared_ptr> & argsGroup){ + return rxcpp::from(argsGroup) // group items by concurrency field .group_by([](const item& i){ return i.concurrency;} ) - // select only the times field - .select([=] (const std::shared_ptr> & gob){ - return std::make_pair( - gob->Key(), // keep concurrency key - rxcpp::from(gob) + // flatten times in the same concurrency + .select_many( + [](const std::shared_ptr> & concurrencyGroup){ + return rxcpp::from(concurrencyGroup) .select([](const item& i){ - return i.time;} - ) - .publish());} + return i.time;}) + .to_vector() + .publish();}, + [](const std::shared_ptr> & concurrencyGroup, + const std::vector & times){ + return std::make_tuple(concurrencyGroup->Key(), times);} ) - .publish());} + .to_vector() + .publish();}, + [](const std::shared_ptr> & argsGroup, + const std::vector>> & ouputGroup){ + return std::make_tuple(argsGroup->Key(), ouputGroup);} ) .observe_on(output) - // print the grouped results - // for_each the args to block until the nested subscribes have finished - .for_each([&](const std::pair, std::shared_ptr > > > > >& ob){ - auto argsstate = std::make_shared>(false, ob.first, arggroupcount++); - rxcpp::from(ob.second) - // subscribe the concurrencies within each args - .subscribe([=](const std::pair > >& ob){ - auto linestate = std::make_shared>>(ob.first, std::vector()); - rxcpp::from(ob.second) - // subscribe the times within each concurrency - .subscribe([=](const double& i){ - // collect the times - linestate->second.push_back(i); - },[=]{ - // this concurrency's times are complete - // output a line to the console. - - if (!std::get<0>(*argsstate)) - { - std::get<0>(*argsstate) = true; - cout<<"arguments: "<(*argsstate)<first << ", "; + .for_each(rxcpp::MakeTupleDispatch( + [](const std::string& args, const std::vector>>& concurrencyGroup){ + cout<<"arguments: "<< args << endl; + cout << "concurrency, mean, |, raw_data," << endl; + for(auto& concurrencyItem : concurrencyGroup) { + rxcpp::MakeTupleDispatch( + [](int concurrency, const std::vector& rawtimes){ + cout << concurrency << ", "; - auto n = from(linestate->second).count(); - auto sum = std::accumulate(linestate->second.begin(), linestate->second.end(), 0.0); - - cout << (sum / n) << ", |"; - - for (auto timeIter = linestate->second.begin(), end = linestate->second.end(); - timeIter != end; - ++timeIter) - { - cout << ", " << *timeIter; - } - cout << endl; - }); - }); - }); + auto n = from(rawtimes).count(); + auto sum = std::accumulate(rawtimes.begin(), rawtimes.end(), 0.0); + + cout << (sum / n) << ", |"; + + for (auto timeIter = rawtimes.begin(), end = rawtimes.end(); + timeIter != end; + ++timeIter) + { + cout << ", " << *timeIter; + } + cout << endl;})(concurrencyItem);}}) + ); } template -- GitLab From 3ea208dcdbd615939292b2fae265ff1310a121ad Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Mar 2013 23:14:37 -0700 Subject: [PATCH 032/782] add take_until, skip and skip_until --- Rx/CPP/src/cpprx/rx-operators.hpp | 218 +++++++++++++++++++++++++++++- Rx/CPP/src/cpprx/rx.hpp | 40 ++++-- 2 files changed, 241 insertions(+), 17 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 8ee85e1..bbd4668 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -234,6 +234,9 @@ namespace rxcpp class Subject : public ObserverSubject, Subject>> { + public: + std::shared_ptr> observable(){return std::static_pointer_cast>(this->shared_from_this());} + std::shared_ptr> observer(){return std::static_pointer_cast>(this->shared_from_this());} }; template @@ -260,6 +263,9 @@ namespace rxcpp typedef ObserverSubject, GroupedSubject>>> base; public: GroupedSubject(K key) : base(std::move(key)) {} + std::shared_ptr> observable(){return std::static_pointer_cast>(this->shared_from_this());} + std::shared_ptr> observer(){return std::static_pointer_cast>(this->shared_from_this());} + std::shared_ptr> grouped_observable(){return std::static_pointer_cast>(this->shared_from_this());} }; template @@ -996,10 +1002,10 @@ namespace rxcpp }); } - template + template std::shared_ptr> Take( const std::shared_ptr>& source, - int n // TODO: long long? + Integral n ) { return CreateObservable( @@ -1007,7 +1013,7 @@ namespace rxcpp -> Disposable { // keep count of remaining calls received OnNext and count of OnNext calls issued. - auto remaining = std::make_shared, std::atomic>>(n, n); + auto remaining = std::make_shared, std::atomic>>(n, n); ComposableDisposable cd; @@ -1040,15 +1046,217 @@ namespace rxcpp // on error [=](const std::exception_ptr& error) { - if (std::get<1>(*remaining) == 0 && std::get<0>(*remaining) <= 0) { - observer->OnError(error); + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } + + template + std::shared_ptr> TakeUntil( + const std::shared_ptr>& source, + const std::shared_ptr>& terminus + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + + struct TerminusState { + enum type { + Live, + Terminated + }; + }; + struct TakeState { + enum type { + Taking, + Completed + }; + }; + struct State { + State() : terminusState(TerminusState::Live), takeState(TakeState::Taking) {} + std::atomic terminusState; + std::atomic takeState; + }; + auto state = std::make_shared(); + + ComposableDisposable cd; + + cd.Add(Subscribe( + terminus, + // on next + [=](const T& element) + { + state->terminusState = TerminusState::Terminated; + }, + // on completed + [=] + { + state->terminusState = TerminusState::Terminated; + }, + // on error + [=](const std::exception_ptr& error) + { + state->terminusState = TerminusState::Terminated; + })); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (state->terminusState == TerminusState::Live) { + observer->OnNext(element); + } else if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { + observer->OnCompleted(); cd.Dispose(); } + }, + // on completed + [=] + { + if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { + state->terminusState = TerminusState::Terminated; + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + state->takeState = TakeState::Completed; + state->terminusState = TerminusState::Terminated; + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } + + template + std::shared_ptr> Skip( + const std::shared_ptr>& source, + Integral n + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + enum type { + Skipping, + Forwarding + }; + }; + // keep count of remaining OnNext calls to skip and state. + auto remaining = std::make_shared, std::atomic>>(n, State::Skipping); + + ComposableDisposable cd; + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (std::get<1>(*remaining) == State::Forwarding) { + observer->OnNext(element); + } else { + auto local = --std::get<0>(*remaining); + + if (local == 0) { + std::get<1>(*remaining) = State::Forwarding; + observer->OnNext(element); + } + } + }, + // on completed + [=] + { + observer->OnCompleted(); + cd.Dispose(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } + + template + std::shared_ptr> SkipUntil( + const std::shared_ptr>& source, + const std::shared_ptr>& terminus + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct SkipState { + enum type { + Skipping, + Taking + }; + }; + struct State { + State() : skipState(SkipState::Skipping) {} + std::atomic skipState; + }; + auto state = std::make_shared(); + + ComposableDisposable cd; + + cd.Add(Subscribe( + terminus, + // on next + [=](const T& element) + { + state->skipState = SkipState::Taking; + }, + // on completed + [=] + { + state->skipState = SkipState::Taking; + }, + // on error + [=](const std::exception_ptr& error) + { + state->skipState = SkipState::Taking; + })); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (state->skipState == SkipState::Taking) { + observer->OnNext(element); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + cd.Dispose(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); })); return cd; }); } + template const std::shared_ptr> ToStdCollection( const std::shared_ptr>& source diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index a51f3ef..cc1e88b 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -58,16 +58,6 @@ namespace rxcpp -> decltype(from(SelectMany(obj, util::pass_through(), util::pass_through_second()))) { return from(SelectMany(obj, util::pass_through(), util::pass_through_second())); } - template - auto select_many(CS collectionSelector) - -> decltype(from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second()))) { - return from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second())); - } - template - auto select_many(CS collectionSelector, RS resultSelector) - -> decltype(from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector)))) { - return from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector))); - } }; template @@ -92,6 +82,16 @@ namespace rxcpp auto select(S selector) -> decltype(from(Select(obj, selector))) { return from(Select(obj, selector)); } + template + auto select_many(CS collectionSelector) + -> decltype(from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second()))) { + return from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second())); + } + template + auto select_many(CS collectionSelector, RS resultSelector) + -> decltype(from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector)))) { + return from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector))); + } #if RXCPP_USE_VARIADIC_TEMPLATES template auto merge(const MergeSource&... source) @@ -148,8 +148,24 @@ namespace rxcpp return from(GroupBy(obj, keySelector, valueSelector, less)); } template - auto take(Integral n) -> decltype(from(Take(obj, n))) { - return from(Take(obj, n)); + auto take(Integral n) + -> decltype(from(Take(obj, n))) { + return from(Take(obj, n)); + } + template + auto take_until(std::shared_ptr> terminus) + -> decltype(from(TakeUntil(obj, terminus))) { + return from(TakeUntil(obj, terminus)); + } + template + auto skip(Integral n) + -> decltype(from(Skip(obj, n))) { + return from(Skip(obj, n)); + } + template + auto skip_until(std::shared_ptr> terminus) + -> decltype(from(SkipUntil(obj, terminus))) { + return from(SkipUntil(obj, terminus)); } templateclass Allocator> auto to_vector() -- GitLab From 75908d25adab4f935209e272a3ee1287be325038 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 30 Mar 2013 00:03:52 -0700 Subject: [PATCH 033/782] adds interval and throttle --- Rx/CPP/src/cpprx/rx-base.hpp | 9 +- Rx/CPP/src/cpprx/rx-operators.hpp | 293 +++++++++++++++++++++++++++++- Rx/CPP/src/cpprx/rx-util.hpp | 162 +++++++++++++++++ Rx/CPP/src/cpprx/rx.hpp | 125 ++++++++++++- Rx/CPP/testbench/testbench.cpp | 55 ++++-- 5 files changed, 626 insertions(+), 18 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 970c3c0..091e6e5 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -300,8 +300,13 @@ namespace rxcpp TupleDispatch(Target target) : target(std::move(target)) { } template - auto operator()(const Tuple& tuple) -> decltype(util::tuple_dispatch(target, tuple)) { - return util::tuple_dispatch(target, tuple);} + auto operator()(const Tuple& tuple) + -> decltype(util::tuple_dispatch(target, tuple)) { + return util::tuple_dispatch(target, tuple);} + template + auto operator()(const Tuple& tuple) const + -> decltype(util::tuple_dispatch(target, tuple)) { + return util::tuple_dispatch(target, tuple);} }; template diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index bbd4668..293d2b5 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -346,6 +346,55 @@ namespace rxcpp }); } + std::shared_ptr> Interval( + Scheduler::clock::duration due, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State : public std::enable_shared_from_this { + State(Scheduler::clock::duration due, + Scheduler::clock::time_point last, + std::shared_ptr> observer) : due(due), last(last), cursor(0), observer(observer) { + cd.Add(sd);} + + Scheduler::clock::duration due; + Scheduler::clock::time_point last; + size_t cursor; + std::shared_ptr> observer; + ComposableDisposable cd; + SharedDisposable sd; + + void Tick(Scheduler::shared s){ + observer->OnNext(cursor); + last += due; + ++cursor; + auto keepAlive = this->shared_from_this(); + sd.Set(s->Schedule( + last, + [this, keepAlive] (Scheduler::shared s){ + Tick(s); + return Disposable::Empty(); + } + )); + } + }; + auto state = std::make_shared(due, scheduler->Now(), observer); + + state->last += state->due; + state->sd.Set(scheduler->Schedule( + state->last, + [=] (Scheduler::shared s){ + state->Tick(s); + return Disposable::Empty(); + } + )); + return state->cd; + }); + } + ////////////////////////////////////////////////////////////////////// // @@ -570,7 +619,6 @@ namespace rxcpp }); } -#if RXCPP_USE_VARIADIC_TEMPLATES namespace detail{ template struct CombineLatestSubscriber { @@ -643,6 +691,8 @@ namespace rxcpp const typename SubscribeState::Sources& ) {} }; } + +#if RXCPP_USE_VARIADIC_TEMPLATES template auto CombineLatest( S selector, @@ -684,6 +734,50 @@ namespace rxcpp return cd; }); } +#else + template + auto CombineLatest( + S selector, + const std::shared_ptr>& source1, + const std::shared_ptr>& source2 + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>, std::shared_ptr>> Sources; + typedef std::tuple Latest; + struct State { + typedef Latest Latest; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : pendingFirst(SourcesSize::value) + , pendingIssue(0) + , pendingComplete(SourcesSize::value) + , done(false) + , selector(std::move(selector)) + {} + std::mutex lock; + size_t pendingFirst; + size_t pendingIssue; + size_t pendingComplete; + bool done; + S selector; + Latest latest; + }; + Sources sources(source1, source2); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#endif namespace detail{ template @@ -706,6 +800,7 @@ namespace rxcpp , observer(observer) , cd(cd) { } +#if RXCPP_USE_VARIADIC_TEMPLATES template void operator()(ZipQueue&... queue) { // build array of bool that we can iterate to detect empty queues @@ -741,6 +836,43 @@ namespace rxcpp cd.Dispose(); } } +#else + template + void operator()(ZipQueue1& queue1, ZipQueue2& queue2) { + // build array of bool that we can iterate to detect empty queues + bool empties[] = {queue1.empty(), queue2.empty()}; + if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { + // all queues have an item. + // + // copy front of each queue + auto args = std::make_tuple(queue1.front(), queue2.front()); + + queue1.pop(); + queue2.pop(); + + ++state->pending; + auto result = util::tuple_dispatch(state->selector, args); + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(result)); + } + --state->pending; + } + // build new array to check for any empty queue + bool post_empties[] = {queue1.empty(), queue2.empty()}; + if (state->completed && state->pending == 0 && + std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { + // at least one queue is empty and at least one of the sources has completed. + // it is time to stop. + + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnCompleted(); + cd.Dispose(); + } + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES }; static void subscribe( ComposableDisposable& cd, @@ -784,6 +916,7 @@ namespace rxcpp const typename SubscribeState::Sources& ) {} }; } +#if RXCPP_USE_VARIADIC_TEMPLATES template auto Zip( S selector, @@ -793,7 +926,7 @@ namespace rxcpp { typedef typename std::result_of::type result_type; typedef std::tuple>...> Sources; - typedef std::tuple>>...> Queues; + typedef std::tuple...> Queues; struct State { typedef Queues Queues; typedef Sources Sources; @@ -821,6 +954,46 @@ namespace rxcpp return cd; }); } +#else + template + auto Zip( + S selector, + const std::shared_ptr>& source1, + const std::shared_ptr>& source2 + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>, std::shared_ptr>> Sources; + typedef std::tuple, std::queue> Queues; + struct State { + typedef Queues Queues; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : selector(std::move(selector)) + , pending(0) + , completed(false) + {} + std::mutex lock; + S selector; + size_t pending; + bool completed; + Queues queues; + }; + Sources sources(source1, source2); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES namespace detail{ template @@ -866,6 +1039,7 @@ namespace rxcpp const typename SubscribeState::Sources& ) {} }; } +#if RXCPP_USE_VARIADIC_TEMPLATES template std::shared_ptr> Merge( const std::shared_ptr>& firstSource, @@ -894,6 +1068,35 @@ namespace rxcpp return cd; }); } +#else + template + std::shared_ptr> Merge( + const std::shared_ptr>& firstSource, + const std::shared_ptr>& otherSource + ) + { + typedef MergeSource result_type; + typedef decltype(std::make_tuple(firstSource, otherSource)) Sources; + struct State { + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + State() + : pendingComplete(SourcesSize::value) + {} + std::atomic pendingComplete; + }; + Sources sources(firstSource, otherSource); + // bug on osx prevents using make_shared + std::shared_ptr state(new State()); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } #endif //RXCPP_USE_VARIADIC_TEMPLATES template @@ -1169,7 +1372,6 @@ namespace rxcpp if (local == 0) { std::get<1>(*remaining) = State::Forwarding; - observer->OnNext(element); } } }, @@ -1347,6 +1549,91 @@ namespace rxcpp }); } + template + std::shared_ptr> Throttle( + const std::shared_ptr>& source, + Scheduler::clock::duration due, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + State() : hasValue(false), id(0) {} + std::mutex lock; + T value; + bool hasValue; + size_t id; + }; + auto state = std::make_shared(); + + ComposableDisposable cd; + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + size_t current = 0; + { + std::unique_lock guard(state->lock); + state->hasValue = true; + state->value = std::move(element); + current = ++state->id; + } + sd.Set(scheduler->Schedule( + due, + [=] (Scheduler::shared){ + { + std::unique_lock guard(state->lock); + if (state->hasValue && state->id == current) { + observer->OnNext(std::move(state->value)); + } + state->hasValue = false; + } + + return Disposable::Empty(); + } + )); + }, + // on completed + [=] + { + bool sendValue = false; + T value; + { + std::unique_lock guard(state->lock); + sendValue = state->hasValue; + if (sendValue) { + value = std::move(state->value);} + state->hasValue = false; + ++state->id; + } + if (sendValue) { + observer->OnNext(std::move(value));} + observer->OnCompleted(); + cd.Dispose(); + }, + // on error + [=](const std::exception_ptr& error) + { + { + std::unique_lock guard(state->lock); + state->hasValue = false; + ++state->id; + } + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } + + // no more than one event ever 'milliseconds' // TODO: oops, this is not the right definition for throttle. template diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index d869577..cf7ad04 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -322,6 +322,168 @@ namespace rxcpp { namespace util { -> decltype(detail::tuple_dispatch::type>::value>::call(std::forward(f), std::forward(t))) { return detail::tuple_dispatch::type>::value>::call(std::forward(f), std::forward(t)); } + + struct as_tuple { + auto operator()() + -> decltype(std::make_tuple()) { + return std::make_tuple();} + template + auto operator()(AsTupleNext x) + -> decltype(std::make_tuple(std::move(x))) { + return std::make_tuple(std::move(x));} + template< + class AsTupleNext1, + class AsTupleNext2> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2) + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2))) { + return std::make_tuple( + std::move(x1), + std::move(x2));} + template< + class AsTupleNext1, + class AsTupleNext2, + class AsTupleNext3> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2, + AsTupleNext3 x3) + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3))) { + return std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3));} + template< + class AsTupleNext1, + class AsTupleNext2, + class AsTupleNext3, + class AsTupleNext4> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2, + AsTupleNext3 x3, + AsTupleNext4 x4) + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4))) { + return std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4));} + template< + class AsTupleNext1, + class AsTupleNext2, + class AsTupleNext3, + class AsTupleNext4, + class AsTupleNext5> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2, + AsTupleNext3 x3, + AsTupleNext4 x4, + AsTupleNext5 x5) + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4), + std::move(x5))) { + return std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4), + std::move(x5));} + + auto operator()() const + -> decltype(std::make_tuple()) { + return std::make_tuple();} + template + auto operator()(AsTupleNext x) const + -> decltype(std::make_tuple(std::move(x))) { + return std::make_tuple(std::move(x));} + template< + class AsTupleNext1, + class AsTupleNext2> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2) const + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2))) { + return std::make_tuple( + std::move(x1), + std::move(x2));} + template< + class AsTupleNext1, + class AsTupleNext2, + class AsTupleNext3> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2, + AsTupleNext3 x3) const + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3))) { + return std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3));} + template< + class AsTupleNext1, + class AsTupleNext2, + class AsTupleNext3, + class AsTupleNext4> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2, + AsTupleNext3 x3, + AsTupleNext4 x4) const + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4))) { + return std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4));} + template< + class AsTupleNext1, + class AsTupleNext2, + class AsTupleNext3, + class AsTupleNext4, + class AsTupleNext5> + auto operator()( + AsTupleNext1 x1, + AsTupleNext2 x2, + AsTupleNext3 x3, + AsTupleNext4 x4, + AsTupleNext5 x5) const + -> decltype(std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4), + std::move(x5))) { + return std::make_tuple( + std::move(x1), + std::move(x2), + std::move(x3), + std::move(x4), + std::move(x5));} + }; #endif //RXCPP_USE_VARIADIC_TEMPLATES struct pass_through { diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index cc1e88b..ba50526 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -98,6 +98,14 @@ namespace rxcpp -> decltype(from(Merge(obj, source...))) { return from(Merge(obj, source...)); } +#else + template + auto merge(const MergeSource& source) + -> decltype(from(Merge(obj, source))) { + return from(Merge(obj, source)); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES +#if RXCPP_USE_VARIADIC_TEMPLATES template auto zip(S selector, const ZipSource&... source) -> decltype(from(Zip(selector, obj, source...))) { @@ -108,6 +116,19 @@ namespace rxcpp -> decltype(from(Zip(util::as_tuple(), obj, source...))) { return from(Zip(util::as_tuple(), obj, source...)); } +#else + template + auto zip(S selector, const ZipSource& source) + -> decltype(from(Zip(selector, obj, source))) { + return from(Zip(selector, obj, source)); + } + template + auto zip(const Zip1Source& source) + -> decltype(from(Zip(util::as_tuple(), obj, source))) { + return from(Zip(util::as_tuple(), obj, source)); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES +#if RXCPP_USE_VARIADIC_TEMPLATES template auto combine_latest(S selector, const CombineLSource&... source) -> decltype(from(CombineLatest(selector, obj, source...))) { @@ -118,6 +139,17 @@ namespace rxcpp -> decltype(from(CombineLatest(util::as_tuple(), obj, source...))) { return from(CombineLatest(util::as_tuple(), obj, source...)); } +#else + template + auto combine_latest(S selector, const CombineLSource& source) + -> decltype(from(CombineLatest(selector, obj, source))) { + return from(CombineLatest(selector, obj, source)); + } + template + auto combine_latest(const CombineLSource& source) + -> decltype(from(CombineLatest(util::as_tuple(), obj, source))) { + return from(CombineLatest(util::as_tuple(), obj, source)); + } #endif //RXCPP_USE_VARIADIC_TEMPLATES template auto where(P predicate) -> decltype(from(Where(obj, predicate))) { @@ -188,6 +220,10 @@ namespace rxcpp auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { return from(Delay(obj, due, scheduler)); } + auto throttle(Scheduler::clock::duration due, Scheduler::shared scheduler) + -> decltype(from(Throttle(obj, due, scheduler))) { + return from(Throttle(obj, due, scheduler)); + } auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { return from(LimitWindow(obj, milliseconds)); } @@ -230,12 +266,99 @@ namespace rxcpp auto result = Subscribe(obj, onNext, onComplete, onError); return result; } -#if RXCPP_USE_VARIADIC_TEMPLATES +#if RXCPP_USE_VARIADIC_TEMPLATE template auto chain(ChainArg&&... arg) -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)...))) { return from(rxcpp_chain(Tag(), obj, std::forward(arg)...)); } +#else + template + auto chain() + -> decltype(from(rxcpp_chain(Tag(), obj))) { + return from(rxcpp_chain(Tag(), obj)); + } + template + auto chain(ChainArg&& arg) + -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)))) { + return from(rxcpp_chain(Tag(), obj, std::forward(arg))); + } + template + auto chain( + ChainArg1&& arg1, + ChainArg2&& arg2) + -> decltype(from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2)))) { + return from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2))); + } + template + auto chain( + ChainArg1&& arg1, + ChainArg2&& arg2, + ChainArg3&& arg3) + -> decltype(from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2), + std::forward(arg3)))) { + return from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2), + std::forward(arg3))); + } + template + auto chain( + ChainArg1&& arg1, + ChainArg2&& arg2, + ChainArg3&& arg3, + ChainArg4&& arg4) + -> decltype(from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2), + std::forward(arg3), + std::forward(arg4)))) { + return from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2), + std::forward(arg3), + std::forward(arg4))); + } + template + auto chain( + ChainArg1&& arg1, + ChainArg2&& arg2, + ChainArg3&& arg3, + ChainArg4&& arg4, + ChainArg5&& arg5) + -> decltype(from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2), + std::forward(arg3), + std::forward(arg4), + std::forward(arg5)))) { + return from(rxcpp_chain(Tag(), obj, + std::forward(arg1), + std::forward(arg2), + std::forward(arg3), + std::forward(arg4), + std::forward(arg5))); + } #endif }; diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index c1913ae..6f48364 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -34,7 +34,6 @@ void PrintPrimes(int n) void Combine(int n) { -#if RXCPP_USE_VARIADIC_TEMPLATES auto input1 = std::make_shared(); auto input2 = std::make_shared(); auto output = std::make_shared(); @@ -58,9 +57,6 @@ void Combine(int n) [](int p2, int p1) { cout << p2 << " =combined=> " << p1 << endl; })); -#else - (void)n; -#endif //RXCPP_USE_VARIADIC_TEMPLATES } struct Count { @@ -114,7 +110,6 @@ rxcpp::Binder>> rxcpp_chain(record&&, const template void Zip(int n) { -#if RXCPP_USE_VARIADIC_TEMPLATES auto input1 = std::make_shared(); auto input2 = std::make_shared(); auto output = std::make_shared(); @@ -152,14 +147,10 @@ void Zip(int n) cout << "zipcount:" << zipcount.nexts << ", " << zipcount.completions << ", " << zipcount.errors << ", " << zipcount.disposals << endl; cout << "takecount:" << takecount.nexts << ", " << takecount.completions << ", " << takecount.errors << ", " << takecount.disposals << endl; cout << "outputcount:" << outputcount.nexts << ", " << outputcount.completions << ", " << outputcount.errors << ", " << outputcount.disposals << endl; -#else - (void)n; -#endif //RXCPP_USE_VARIADIC_TEMPLATES } void Merge(int n) { -#if RXCPP_USE_VARIADIC_TEMPLATES auto input1 = std::make_shared(); auto input2 = std::make_shared(); auto output = std::make_shared(); @@ -185,9 +176,48 @@ void Merge(int n) [](const char* s, int p) { cout << s << p << endl; })); -#else - (void)n; -#endif //RXCPP_USE_VARIADIC_TEMPLATES +} + +void PrintIntervals(int n) { + using namespace std::chrono; + typedef steady_clock clock; + struct Tick { + Tick(size_t c, clock::time_point at) : cursor(c), at(at) {} + size_t cursor; + clock::time_point at; + }; + auto source = std::make_shared(); + auto subject = rxcpp::CreateSubject(); + + cout << "Intervals of .5 second: " << endl; + rxcpp::from(subject) + .zip(rxcpp::from(subject).skip(1).publish()) + .select(rxcpp::MakeTupleDispatch( + [=](Tick a, Tick b){ + return duration_cast(b.at.time_since_epoch()) - + duration_cast(a.at.time_since_epoch());})) + .to_vector() + .subscribe( + // on next + [=](std::vector d) + { + cout << endl; + auto l = std::max_element(d.begin(), d.end()); + auto s = std::min_element(d.begin(), d.end()); + cout << "range: " << s->count() << "-" << l->count() << endl; + }); + + rxcpp::from(rxcpp::Interval(std::chrono::milliseconds(500), source)) + .select([](size_t interval){return Tick(interval, clock::now());}) + .take(n) + .for_each( + // on next + [=](Tick t) + { + cout << "."; + subject->OnNext(std::move(t)); + }); + subject->OnCompleted(); } std::shared_ptr> Data( @@ -296,6 +326,7 @@ void innerScheduler() { int main(int argc, char* argv[]) { try { + PrintIntervals(10); PrintPrimes(20); cout << "Zip Immediate" << endl; Zip(20); -- GitLab From 57ca6b685eb6cbb4e5233551be1b66da5e5a0846 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 31 Mar 2013 12:09:25 -0700 Subject: [PATCH 034/782] adds from_iterable from_iterable(r, opt - scheduler) adapts any r that satisfies std::begin(r) and std::end(r) into an Observable --- Ix/CPP/src/cpplinq/util.hpp | 10 +---- Rx/CPP/src/cpprx/rx-base.hpp | 5 --- Rx/CPP/src/cpprx/rx-operators.hpp | 63 +++++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-util.hpp | 43 +-------------------- Rx/CPP/src/cpprx/rx.hpp | 10 +++++ Rx/CPP/testbench/testbench.cpp | 38 ++++++++++++++++--- 6 files changed, 108 insertions(+), 61 deletions(-) diff --git a/Ix/CPP/src/cpplinq/util.hpp b/Ix/CPP/src/cpplinq/util.hpp index 953a48a..ee3d7eb 100644 --- a/Ix/CPP/src/cpplinq/util.hpp +++ b/Ix/CPP/src/cpplinq/util.hpp @@ -192,15 +192,7 @@ namespace cpplinq { namespace util { return is_set ? reinterpret_cast(&storage) : 0; } - void set(const T& value) { - if (is_set) { - *reinterpret_cast(&storage) = value; - } else { - new (reinterpret_cast(&storage)) T(value); - is_set = true; - } - } - void set(T&& value) { + void set(T value) { if (is_set) { *reinterpret_cast(&storage) = std::move(value); } else { diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 091e6e5..21921c1 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -319,11 +319,6 @@ namespace rxcpp return util::tuple_dispatch(std::forward(target), std::forward(tuple));} #if RXCPP_USE_VARIADIC_TEMPLATES - template - auto ConcatTuple(Lhs&& lhs, Rhs&& rhs) -> - decltype(util::tuple_concat(std::forward(lhs), std::forward(rhs))) { - return util::tuple_concat(std::forward(lhs), std::forward(rhs));} - template auto TieTuple(T&& t) -> decltype(util::tuple_tie(std::forward(t))) { diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 293d2b5..0319949 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -395,6 +395,69 @@ namespace rxcpp }); } + using std::begin; + using std::end; + template + auto FromIterable( + Range r, + Scheduler::shared scheduler = nullptr) + -> std::shared_ptr> + { + typedef decltype(begin(r)) It; + typedef decltype(*begin(r)) T; + + if (!scheduler) {scheduler = std::make_shared();} + auto range = std::make_shared(std::move(r)); + + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + explicit State(std::shared_ptr rangeArg) : cancel(false) { + this->range = std::move(rangeArg); + this->r_cursor = begin(*this->range); + this->r_end = end(*this->range); + } + bool cancel; + std::shared_ptr range; + It r_cursor; + It r_end; + }; + auto state = std::make_shared(range); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + try { + if (state->cancel) + return Disposable::Empty(); + + if (state->r_cursor == state->r_end) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(*state->r_cursor); + ++state->r_cursor; + return s->Schedule(std::move(self)); + } + } catch (...) { + observer->OnError(std::current_exception()); + } + return Disposable::Empty(); + }))); + + return cd; + }); + } ////////////////////////////////////////////////////////////////////// // diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index cf7ad04..a7f2a23 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -94,15 +94,7 @@ namespace rxcpp { namespace util { return is_set ? reinterpret_cast(&storage) : 0; } - void set(const T& value) { - if (is_set) { - *reinterpret_cast(&storage) = value; - } else { - new (reinterpret_cast(&storage)) T(value); - is_set = true; - } - } - void set(T&& value) { + void set(T value) { if (is_set) { *reinterpret_cast(&storage) = std::move(value); } else { @@ -179,39 +171,6 @@ namespace rxcpp { namespace util { return detail::tuple_dispatch::type>::type>::call(std::forward(f), std::forward(t)); } - namespace detail { - template - struct tuple_concat; - template - struct tuple_concat, tuple_indices> { - template - static - auto concatenate(LhsTuple&& lhs, RhsTuple&& rhs) - -> decltype (std::tuple< - typename std::tuple_element::type>::type..., - typename std::tuple_element::type>::type...>( - std::get(std::forward(lhs))..., - std::get(std::forward(rhs))...)) { - return std::tuple< - typename std::tuple_element::type>::type..., - typename std::tuple_element::type>::type...>( - std::get(std::forward(lhs))..., - std::get(std::forward(rhs))...); - } - };} - - template - auto tuple_concat(LhsTuple&& lhs, RhsTuple&& rhs) - -> decltype(detail::tuple_concat< - typename make_tuple_indices::type>::type, - typename make_tuple_indices::type>::type>:: - concatenate(std::forward(lhs), std::forward(rhs))) { - return detail::tuple_concat< - typename make_tuple_indices::type>::type, - typename make_tuple_indices::type>::type>:: - concatenate(std::forward(lhs), std::forward(rhs)); - } - namespace detail { template struct tuple_tie; diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index ba50526..562f097 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -382,6 +382,16 @@ namespace rxcpp Binder from(Binder binder) { return std::move(binder); } + template + auto from_iterable(Range r) + -> decltype(from(FromIterable(std::move(r)))) { + return from(FromIterable(std::move(r))); } + + template + auto from_iterable(Range r, Scheduler::shared scheduler) + -> decltype(from(FromIterable(std::move(r), std::move(scheduler)))) { + return from(FromIterable(std::move(r), std::move(scheduler))); } + template T item(const Binder>>&); diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 6f48364..fdb0dd5 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -18,15 +18,42 @@ using namespace std; bool IsPrime(int x); +vector vector_range(int start, int end) +{ + vector v; + for (int i = start; i < end; ++i) + v.push_back(i); + return v; +} + +void IxToRx(int n) { + std::cout << "IxToRx: first " << n << " primes squared" << endl; + auto values = vector_range(2, n * 10); + + auto primes = cpplinq::from(values) + .where(IsPrime) + .select([](int x) { return std::make_pair(x, x*x); }); + + auto input = std::make_shared(); + auto output = std::make_shared(); + rxcpp::from_iterable(primes, input) + .take(n) + .observe_on(output) + .for_each(rxcpp::MakeTupleDispatch( + [](int p, int s) { + cout << p << " =square=> " << s << endl; + })); +} + void PrintPrimes(int n) { - std::cout << "first " << n << " primes squared" << endl; + std::cout << "Rx: first " << n << " primes squared" << endl; auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values) + rxcpp::from(values) .where(IsPrime) .select([](int x) { return std::make_pair(x, x*x); }) .take(n) - .subscribe(rxcpp::MakeTupleDispatch( + .for_each(rxcpp::MakeTupleDispatch( [](int p, int s) { cout << p << " =square=> " << s << endl; })); @@ -189,7 +216,7 @@ void PrintIntervals(int n) { auto source = std::make_shared(); auto subject = rxcpp::CreateSubject(); - cout << "Intervals of .5 second: " << endl; + cout << n << " Intervals of .5 second: " << endl; rxcpp::from(subject) .zip(rxcpp::from(subject).skip(1).publish()) .select(rxcpp::MakeTupleDispatch( @@ -204,7 +231,7 @@ void PrintIntervals(int n) { cout << endl; auto l = std::max_element(d.begin(), d.end()); auto s = std::min_element(d.begin(), d.end()); - cout << "range: " << s->count() << "-" << l->count() << endl; + cout << "range: " << s->count() << "ms-" << l->count() << "ms" << endl; }); rxcpp::from(rxcpp::Interval(std::chrono::milliseconds(500), source)) @@ -327,6 +354,7 @@ int main(int argc, char* argv[]) { try { PrintIntervals(10); + IxToRx(20); PrintPrimes(20); cout << "Zip Immediate" << endl; Zip(20); -- GitLab From 6a7b68113a3787da5eef670ae092e0ce9f052b32 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 31 Mar 2013 21:18:25 -0700 Subject: [PATCH 035/782] change from_iterable to from(Iterate()) --- Rx/CPP/src/cpprx/rx-operators.hpp | 2 +- Rx/CPP/src/cpprx/rx.hpp | 10 ---------- Rx/CPP/testbench/testbench.cpp | 4 ++-- 3 files changed, 3 insertions(+), 13 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 0319949..963bd02 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -398,7 +398,7 @@ namespace rxcpp using std::begin; using std::end; template - auto FromIterable( + auto Iterate( Range r, Scheduler::shared scheduler = nullptr) -> std::shared_ptr> diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 562f097..ba50526 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -382,16 +382,6 @@ namespace rxcpp Binder from(Binder binder) { return std::move(binder); } - template - auto from_iterable(Range r) - -> decltype(from(FromIterable(std::move(r)))) { - return from(FromIterable(std::move(r))); } - - template - auto from_iterable(Range r, Scheduler::shared scheduler) - -> decltype(from(FromIterable(std::move(r), std::move(scheduler)))) { - return from(FromIterable(std::move(r), std::move(scheduler))); } - template T item(const Binder>>&); diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index fdb0dd5..7e28cfa 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -36,7 +36,7 @@ void IxToRx(int n) { auto input = std::make_shared(); auto output = std::make_shared(); - rxcpp::from_iterable(primes, input) + rxcpp::from(Iterate(primes, input)) .take(n) .observe_on(output) .for_each(rxcpp::MakeTupleDispatch( @@ -241,7 +241,7 @@ void PrintIntervals(int n) { // on next [=](Tick t) { - cout << "."; + cout << "." << flush; subject->OnNext(std::move(t)); }); subject->OnCompleted(); -- GitLab From 2c5d2fd4ab4bc412d67299a72d1e3c287aa44dca Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 4 Apr 2013 13:44:45 -0700 Subject: [PATCH 036/782] add concat --- Rx/CPP/src/cpprx/rx-operators.hpp | 171 +++++++++++++++++++++++++++++- Rx/CPP/src/cpprx/rx.hpp | 34 ++++++ Rx/CPP/testbench/testbench.cpp | 33 ++++++ 3 files changed, 235 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 963bd02..939e70b 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -401,10 +401,10 @@ namespace rxcpp auto Iterate( Range r, Scheduler::shared scheduler = nullptr) - -> std::shared_ptr> + -> std::shared_ptr::type>> { typedef decltype(begin(r)) It; - typedef decltype(*begin(r)) T; + typedef typename std::decay::type T; if (!scheduler) {scheduler = std::make_shared();} auto range = std::make_shared(std::move(r)); @@ -544,7 +544,7 @@ namespace rxcpp }); }); } - + template auto SelectMany( const std::shared_ptr>& source, @@ -681,6 +681,171 @@ namespace rxcpp return cd; }); } + + template + ObservableT Concat( + const std::shared_ptr>& source) + { + typedef typename observable_item::type T; + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + bool completed; + bool subscribed; + bool cancel; + std::queue queue; + Scheduler::shared scheduler; + std::mutex lock; + }; + auto state = std::make_shared(); + state->cancel = false; + state->subscribed = 0; + state->scheduler = std::make_shared(); + + ComposableDisposable cd; + + SharedDisposable sd; + cd.Add(sd); + + cd.Add(Disposable([=]{ + std::unique_lock guard(state->lock); + state->cancel = true; }) + ); + + cd.Add(Subscribe( + source, + // on next + [=](const ObservableT& sourceElement) + { + bool cancel = false; + bool subscribed = false; + Scheduler::shared sched; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + sched = state->scheduler; + if (!cancel) { + subscribed = state->subscribed; + state->queue.push(sourceElement); + state->subscribed = true; + sched = state->scheduler; + } + } + if (!cancel && !subscribed) { + sd.Set(sched->Schedule( + fix0([state, cd, sd, observer](Scheduler::shared s, std::function self) -> Disposable + { + try { + bool cancel = false; + bool finished = false; + ObservableT next; + { + std::unique_lock guard(state->lock); + finished = state->queue.empty(); + cancel = state->cancel; + if (!cancel && !finished) {next = state->queue.front(); state->queue.pop();} + } + if (!cancel && !finished) { + sd.Set(Subscribe( + next, + // on next + [=](const T& t) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + try { + if (!cancel) { + observer->OnNext(std::move(t)); + } + } catch (...) { + observer->OnError(std::current_exception()); + cd.Dispose(); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + bool subscribe = false; + { + std::unique_lock guard(state->lock); + finished = state->queue.empty() && state->completed; + subscribe = !state->queue.empty(); + state->subscribed = subscribe; + cancel = state->cancel; + } + if (!cancel) { + if (subscribe) {sd.Set(s->Schedule(std::move(self)));} + else if (finished) {observer->OnCompleted(); cd.Dispose();} + } + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + })); + } + } catch (...) { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + } + return Disposable::Empty(); + }))); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + state->completed = true; + finished = state->queue.empty() && !state->subscribed; + cancel = state->cancel; + } + if (!cancel && finished) { + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + })); + return cd; + }); + } namespace detail{ template diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index ba50526..7089131 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -38,6 +38,9 @@ namespace rxcpp BinderNested(Obj obj) : BinderBase(std::move(obj)) { } + + void select_many(); + void concat(); }; template @@ -58,6 +61,10 @@ namespace rxcpp -> decltype(from(SelectMany(obj, util::pass_through(), util::pass_through_second()))) { return from(SelectMany(obj, util::pass_through(), util::pass_through_second())); } + auto concat() + -> decltype(from(Concat(*(Obj*)nullptr))) { + return from(Concat(obj)); + } }; template @@ -82,6 +89,7 @@ namespace rxcpp auto select(S selector) -> decltype(from(Select(obj, selector))) { return from(Select(obj, selector)); } + using base::select_many; template auto select_many(CS collectionSelector) -> decltype(from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second()))) { @@ -151,6 +159,32 @@ namespace rxcpp return from(CombineLatest(util::as_tuple(), obj, source)); } #endif //RXCPP_USE_VARIADIC_TEMPLATES + + using base::concat; +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto concat(const ConcatSource&... source) + -> decltype(from(Concat(Iterate(std::vector())))) { + std::vector sources; + sources.push_back(obj); + std::make_tuple((sources.push_back(source), true)...); + return from(Concat(Iterate(std::move(sources)))); + } +#else + auto concat(const Obj& source) + -> decltype(from(Concat(Iterate(std::vector())))) { + std::vector sources; + sources.push_back(obj); + sources.push_back(source); + return from(Concat(Iterate(std::move(sources)))); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES + template + auto concat(Range range) + -> decltype(from(Concat(Iterate(range.insert(range.begin(), range.front()), range)))) { + range.insert(range.begin(), obj); + return from(Concat(Iterate(std::move(range)))); + } template auto where(P predicate) -> decltype(from(Where(obj, predicate))) { return from(Where(obj, predicate)); diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 7e28cfa..a610c67 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -59,6 +59,38 @@ void PrintPrimes(int n) })); } +void Concat(int n) +{ + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); + + auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .where(IsPrime) + .select([](int prime){this_thread::yield(); return std::make_tuple("1:", prime);}) + .take(n/2) + .publish(); + + auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers + auto s2 = rxcpp::from(values2) + .subscribe_on(input2) + .where(IsPrime) + .select([](int prime){this_thread::yield(); return std::make_tuple("2:", prime);}) + .take(n/2) + .publish(); + + rxcpp::from(s2) + .concat(s1) + .take(n) + .observe_on(output) + .for_each(rxcpp::MakeTupleDispatch( + [](const char* s, int p) { + cout << s << " =concat=> " << p << endl; + })); +} + void Combine(int n) { auto input1 = std::make_shared(); @@ -364,6 +396,7 @@ int main(int argc, char* argv[]) Zip(20); Combine(20); Merge(20); + Concat(20); innerScheduler(); innerScheduler(); -- GitLab From fd49e3e64be33c22e6071a79a4983e15c620dfc0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 6 Apr 2013 00:50:30 -0700 Subject: [PATCH 037/782] add BehaviorSubject --- Rx/CPP/src/cpprx/rx-base.hpp | 39 ++++++++ Rx/CPP/src/cpprx/rx-includes.hpp | 14 +++ Rx/CPP/src/cpprx/rx-operators.hpp | 146 +++++++++++++++++++++++++++--- Rx/CPP/src/cpprx/rx.hpp | 9 +- 4 files changed, 195 insertions(+), 13 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 21921c1..4a461a7 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -328,6 +328,9 @@ namespace rxcpp template class Subject; + template + class BehaviorSubject; + template class GroupedSubject; @@ -346,6 +349,9 @@ namespace rxcpp template struct is_observable>> {static const bool value = true;}; + template + struct is_observable>> {static const bool value = true;}; + template struct is_observable>> {static const bool value = true;}; @@ -382,16 +388,49 @@ namespace rxcpp template struct subject_item>> {typedef T type;}; + template + struct subject_item>> {typedef T type;}; + + template + struct subject_item>> {typedef T type;}; + template struct subject_observer; template struct subject_observer>> {typedef std::shared_ptr> type;}; + template + struct subject_observer>> {typedef std::shared_ptr> type;}; + template struct subject_observable; template struct subject_observable>> {typedef std::shared_ptr> type;}; + + template + struct subject_observable>> {typedef std::shared_ptr> type;}; + + template + std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + + template + std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + + template + std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + + template + std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + + template + std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + + template + std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + + template + std::shared_ptr> grouped_observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} } #endif diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index 8c861f0..eb57b0c 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -53,6 +53,20 @@ #endif +#if defined(RXCPP_FORCE_USE_VARIADIC_TEMPLATES) +#undef RXCPP_USE_VARIADIC_TEMPLATES +#define RXCPP_USE_VARIADIC_TEMPLATES RXCPP_FORCE_USE_VARIADIC_TEMPLATES +#endif + +#if defined(RXCPP_FORCE_USE_RVALUEREF) +#undef RXCPP_USE_RVALUEREF +#define RXCPP_USE_RVALUEREF RXCPP_FORCE_USE_RVALUEREF +#endif + +#if defined(RXCPP_FORCE_USE_RTTI) +#undef RXCPP_USE_RTTI +#define RXCPP_USE_RTTI RXCPP_FORCE_USE_RTTI +#endif #include "rx-util.hpp" #include "rx-base.hpp" diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 939e70b..234a02a 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -234,9 +234,6 @@ namespace rxcpp class Subject : public ObserverSubject, Subject>> { - public: - std::shared_ptr> observable(){return std::static_pointer_cast>(this->shared_from_this());} - std::shared_ptr> observer(){return std::static_pointer_cast>(this->shared_from_this());} }; template @@ -263,9 +260,6 @@ namespace rxcpp typedef ObserverSubject, GroupedSubject>>> base; public: GroupedSubject(K key) : base(std::move(key)) {} - std::shared_ptr> observable(){return std::static_pointer_cast>(this->shared_from_this());} - std::shared_ptr> observer(){return std::static_pointer_cast>(this->shared_from_this());} - std::shared_ptr> grouped_observable(){return std::static_pointer_cast>(this->shared_from_this());} }; template @@ -274,6 +268,128 @@ namespace rxcpp return std::make_shared>(std::move(key)); } + template + class BehaviorSubject : + public std::enable_shared_from_this>, + public Observable, + public Observer + { + std::mutex lock; + T value; + std::vector>> observers; + + void RemoveObserver(std::shared_ptr> toRemove) + { + std::unique_lock guard(lock); + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } + + BehaviorSubject(); + public: + + explicit BehaviorSubject(T t) : value(std::move(t)) {} + + virtual ~BehaviorSubject() { + // putting this first means that the observers + // will be destructed outside the lock + std::vector>> empty; + + std::unique_lock guard(lock); + using std::swap; + swap(observers, empty); + } + + virtual Disposable Subscribe(std::shared_ptr> observer) + { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d([wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }); + + try + { + { + std::unique_lock guard(lock); + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(observer); + } + observer->OnNext(value); + } + catch (...) + { + observer->OnError(std::current_exception()); + RemoveObserver(observer); + } + + return d; + } + + virtual void OnNext(T element) + { + std::unique_lock guard(lock); + auto local = observers; + value = std::move(element); + guard.unlock(); + for(auto& o : local) + { + try + { + if (o) { + o->OnNext(value); + } + } + catch (...) + { + o->OnError(std::current_exception()); + RemoveObserver(o); + } + } + } + virtual void OnCompleted() + { + std::unique_lock guard(lock); + auto local = std::move(observers); + guard.unlock(); + for(auto& o : local) + { + if (o) { + o->OnCompleted(); + } + } + } + virtual void OnError(const std::exception_ptr& error) + { + std::unique_lock guard(lock); + auto local = std::move(observers); + guard.unlock(); + for(auto& o : local) + { + if (o) { + o->OnError(error); + } + } + } + }; + + template + std::shared_ptr> CreateBehaviorSubject(Arg a) + { + return std::make_shared>(std::move(a)); + } + template struct fix0_thunk { F f; @@ -865,9 +981,9 @@ namespace rxcpp auto local = state; std::unique_lock guard(local->lock); std::get(local->latest) = element; - if (pending) { + if (!std::get(local->latestValid)) { + std::get(local->latestValid) = true; --local->pendingFirst; - pending = false; } if (local->pendingFirst == 0) { Latest args = local->latest; @@ -931,19 +1047,22 @@ namespace rxcpp typedef typename std::result_of::type result_type; typedef std::tuple>...> Sources; typedef std::tuple Latest; + typedef decltype(std::make_tuple((source, true)...)) LatestValid; struct State { typedef Latest Latest; typedef Sources Sources; typedef result_type result_type; typedef std::tuple_size SourcesSize; explicit State(S selector) - : pendingFirst(SourcesSize::value) + : latestValid() + , pendingFirst(SourcesSize::value) , pendingIssue(0) , pendingComplete(SourcesSize::value) , done(false) , selector(std::move(selector)) {} std::mutex lock; + LatestValid latestValid; size_t pendingFirst; size_t pendingIssue; size_t pendingComplete; @@ -953,7 +1072,7 @@ namespace rxcpp }; Sources sources(source...); // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); + std::shared_ptr state(new State(selector)); return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { @@ -974,19 +1093,22 @@ namespace rxcpp typedef typename std::result_of::type result_type; typedef std::tuple>, std::shared_ptr>> Sources; typedef std::tuple Latest; + typedef std::tuple LatestValid; struct State { typedef Latest Latest; typedef Sources Sources; typedef result_type result_type; typedef std::tuple_size SourcesSize; explicit State(S selector) - : pendingFirst(SourcesSize::value) + : latestValid() + , pendingFirst(SourcesSize::value) , pendingIssue(0) , pendingComplete(SourcesSize::value) , done(false) , selector(std::move(selector)) {} std::mutex lock; + LatestValid latestValid; size_t pendingFirst; size_t pendingIssue; size_t pendingComplete; @@ -1930,7 +2052,7 @@ namespace rxcpp // on next [=](const T& element) { - if (!state->hasValue || state->last != element) + if (!state->hasValue || !(state->last == element)) { observer->OnNext(element); state->last = element; diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 7089131..a083904 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -283,6 +283,9 @@ namespace rxcpp void for_each(OnNext onNext) { ForEach(obj, onNext); } + auto subscribe(std::shared_ptr> observer) -> decltype(obj->Subscribe(observer)) { + return obj->Subscribe(observer); + } template auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { auto result = Subscribe(obj, onNext); @@ -406,8 +409,12 @@ namespace rxcpp template Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } + return Binder>>(observable(obj)); } + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(observable(obj)); } + template Binder>> from(std::shared_ptr> obj) { return Binder>>(std::move(obj)); } -- GitLab From 5c4f6752fbf3a1bcb38ef302637a9410d0cee818 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 27 Apr 2013 12:37:26 -0700 Subject: [PATCH 038/782] RxC++: Disposable and Scheduler fixes --- Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 41 +++++++-- Rx/CPP/src/cpprx/rx-base.hpp | 102 ++++++++++++++++----- Rx/CPP/src/cpprx/rx-operators.hpp | 43 ++++++--- Rx/CPP/src/cpprx/rx-scheduler.hpp | 92 ++++++++++++++----- Rx/CPP/src/cpprx/rx-windows.hpp | 12 ++- 5 files changed, 219 insertions(+), 71 deletions(-) diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp index da3d39a..f1bf7a9 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -55,6 +55,11 @@ void CMainFrame::UserInit() // set up labels and query auto msg = L"Time flies like an arrow"; +#if LABEL_EXPRESSION_TRACING + auto start = worker->Now(); + auto ms = std::chrono::milliseconds(1); +#endif + for (int i = 0; msg[i]; ++i) { auto label = CreateLabelFromLetter(msg[i], this); @@ -64,19 +69,44 @@ void CMainFrame::UserInit() // user32 doesn't filter this for you: http://blogs.msdn.com/b/oldnewthing/archive/2003/10/01/55108.aspx auto s = rxcpp::from(mouseMove) - .select([](MouseMoveEventValue e) { return e.point; }) + .select([=](MouseMoveEventValue e) { + auto now = worker->Now(); +#if LABEL_EXPRESSION_TRACING + {std::wstringstream out; + out << L"input index: " << i << L", ms: " << ((now - start) / ms) + << L", x: " << e.point.x << L", y: " << e.point.y + << L", x: " << e.point.x+20*i << L", y: " << e.point.y-20 << std::endl; + OutputDebugString(out.str().c_str());} +#endif + return std::make_tuple(now, e.point); }) .distinct_until_changed() .delay(std::chrono::milliseconds(i * 100 + 1), worker) +#if LABEL_EXPRESSION_TRACING + .select(rxcpp::MakeTupleDispatch([=](rxcpp::Scheduler::clock::time_point time, CPoint point) { + {std::wstringstream out; + out << L"delayed index: " << i << L", ms: " << ((time - start) / ms) + << L", x: " << point.x << L", y: " << point.y + << L", x: " << point.x+20*i << L", y: " << point.y-20 << std::endl; + OutputDebugString(out.str().c_str());} + return std::make_tuple(time, point);;})) +#endif .observe_on(mainFormScheduler) - .subscribe([=](CPoint point) + .subscribe(rxcpp::MakeTupleDispatch([=](rxcpp::Scheduler::clock::time_point time, CPoint point) { +#if LABEL_EXPRESSION_TRACING + {std::wstringstream out; + out << L"observed index: " << i << L", ms: " << ((time - start) / ms) + << L", x: " << point.x << L", y: " << point.y + << L", x: " << point.x+20*i << L", y: " << point.y-20 << std::endl; + OutputDebugString(out.str().c_str());} +#endif label->SetWindowPos(nullptr, point.x+20*i, point.y-20, 20, 30, SWP_NOOWNERZORDER); label->Invalidate(); // repaint early, for fluid animation label->UpdateWindow(); - this->UpdateWindow(); - }); + //this->UpdateWindow(); + })); composableDisposable.Add(std::move(s)); } @@ -84,9 +114,6 @@ void CMainFrame::UserInit() void CMainFrame::OnClose() { - // TODO: figure out cause of crash -- until then, exit instead - ::ExitProcess(0); - // shutdown subscription. composableDisposable.Dispose(); diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 4a461a7..571f482 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -89,23 +89,49 @@ namespace rxcpp // reference handle type for a container for composing disposables class ComposableDisposable { + typedef std::shared_ptr shared_disposable; + typedef std::weak_ptr weak_disposable; struct State { - std::vector disposables; + std::vector disposables; std::mutex lock; bool isDisposed; State() : isDisposed(false) { } - void Add(Disposable&& d) + weak_disposable Add(Disposable&& d) + { + return Add(std::make_shared(std::move(d))); + } + weak_disposable Add(shared_disposable s) { std::unique_lock guard(lock); if (isDisposed) { guard.unlock(); - d.Dispose(); + s->Dispose(); } else { - disposables.emplace_back(std::move(d)); + auto end = std::end(disposables); + auto it = std::find(std::begin(disposables), end, s); + if (it == end) + { + disposables.emplace_back(s); + } + } + return s; + } + void Remove(weak_disposable w) + { + std::unique_lock guard(lock); + auto s = w.lock(); + if (s) + { + auto end = std::end(disposables); + auto it = std::find(std::begin(disposables), end, s); + if (it != end) + { + disposables.erase(it); + } } } void Dispose() @@ -119,22 +145,31 @@ namespace rxcpp guard.unlock(); std::for_each(v.begin(), v.end(), - [](Disposable& d) { - d.Dispose(); }); + [](shared_disposable& d) { + d->Dispose(); }); } } }; - std::shared_ptr state; + mutable std::shared_ptr state; public: - ComposableDisposable() : state(new State) + ComposableDisposable() + : state(std::make_shared()) + { + } + weak_disposable Add(shared_disposable s) const { + return state->Add(std::move(s)); } - void Add(Disposable d) const + weak_disposable Add(Disposable d) const { - state->Add(std::move(d)); + return state->Add(std::move(d)); + } + void Remove(weak_disposable w) const + { + state->Remove(w); } void Dispose() const { @@ -186,6 +221,20 @@ namespace rxcpp : state(new State(std::move(scheduler), std::move(disposable))) { } + ScheduledDisposable(const ScheduledDisposable& o) + : state(o.state) + { + } + ScheduledDisposable(ScheduledDisposable&& o) + : state(std::move(o.state)) + { + o.state = nullptr; + } + ScheduledDisposable& operator=(ScheduledDisposable o) { + using std::swap; + swap(o.state, state); + return *this; + } void Dispose() const { state->Dispose(); @@ -202,37 +251,44 @@ namespace rxcpp } }; - class SharedDisposable + class SerialDisposable { - typedef std::function dispose_type; - - struct State : public std::enable_shared_from_this + struct State { mutable Disposable disposable; + mutable bool disposed; mutable std::mutex lock; - State() : disposable(Disposable::Empty()) {} + State() : disposable(Disposable::Empty()), disposed(false) {} void Set(Disposable disposeArg) const - { + { std::unique_lock guard(lock); - {using std::swap; swap(disposable, disposeArg);} + if (!disposed) { + using std::swap; + swap(disposable, disposeArg); + } + guard.unlock(); + disposeArg.Dispose(); } void Dispose() { std::unique_lock guard(lock); - auto local = std::move(disposable); - guard.unlock(); - local.Dispose(); + if (!disposed) { + disposed = true; + auto local = std::move(disposable); + guard.unlock(); + local.Dispose(); + } } }; - std::shared_ptr state; + mutable std::shared_ptr state; public: - SharedDisposable() - : state(new State()) + SerialDisposable() + : state(std::make_shared()) { } void Dispose() const diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 234a02a..1c726ca 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -26,17 +26,19 @@ namespace rxcpp virtual Disposable Subscribe(std::shared_ptr> observer) { if (CurrentThreadScheduler::IsScheduleRequired()) { + SerialDisposable sd; auto scheduler = std::make_shared(); - return scheduler->Schedule( + scheduler->Schedule( [=](Scheduler::shared) -> Disposable { try { - return subscribe(observer); + sd.Set(subscribe(observer)); } catch (...) { observer->OnError(std::current_exception()); } return Disposable::Empty(); } ); + return sd; } try { return subscribe(observer); @@ -83,16 +85,16 @@ namespace rxcpp if(onCompleted) { onCompleted(); - clear(); } + clear(); } virtual void OnError(const std::exception_ptr& error) { if(onError) { onError(error); - clear(); } + clear(); } void clear() { @@ -481,7 +483,7 @@ namespace rxcpp size_t cursor; std::shared_ptr> observer; ComposableDisposable cd; - SharedDisposable sd; + SerialDisposable sd; void Tick(Scheduler::shared s){ observer->OnNext(cursor); @@ -822,7 +824,7 @@ namespace rxcpp ComposableDisposable cd; - SharedDisposable sd; + SerialDisposable sd; cd.Add(sd); cd.Add(Disposable([=]{ @@ -1858,36 +1860,47 @@ namespace rxcpp ComposableDisposable cd; - cd.Add(Disposable([=]{ *cancel = true; })); + cd.Add(Disposable([=]{ + *cancel = true; })); - SharedDisposable sd; - cd.Add(sd); + SerialDisposable sd; + auto wsd = cd.Add(sd); cd.Add(Subscribe( source, // on next [=](const T& element) { - sd.Set(scheduler->Schedule( + auto sched_disposable = scheduler->Schedule( due, [=] (Scheduler::shared){ if (!*cancel) observer->OnNext(element); return Disposable::Empty(); } - )); + ); + auto ssd = wsd.lock(); + if (ssd) + { + *ssd.get() = std::move(sched_disposable); + } }, // on completed [=] { - sd.Set(scheduler->Schedule( + auto sched_disposable = scheduler->Schedule( due, [=](Scheduler::shared){ if (!*cancel) observer->OnCompleted(); return Disposable::Empty(); } - )); + ); + auto ssd = wsd.lock(); + if (ssd) + { + *ssd.get() = std::move(sched_disposable); + } }, // on error [=](const std::exception_ptr& error) @@ -1920,7 +1933,7 @@ namespace rxcpp ComposableDisposable cd; - SharedDisposable sd; + SerialDisposable sd; cd.Add(sd); cd.Add(Subscribe( @@ -2083,7 +2096,7 @@ namespace rxcpp { ComposableDisposable cd; - SharedDisposable sd; + SerialDisposable sd; cd.Add(sd); cd.Add(scheduler->Schedule([=](Scheduler::shared){ diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 7ecd850..2757acd 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -229,9 +229,9 @@ namespace rxcpp typedef std::function Action; Scheduler::shared scheduler; - std::shared_ptr> observer; std::atomic trampoline; - SharedDisposable sd; + mutable std::shared_ptr> observer; + mutable SerialDisposable sd; mutable std::queue queue; mutable std::mutex lock; @@ -245,8 +245,14 @@ namespace rxcpp void Dispose() const { - std::unique_lock guard(lock); - while (!queue.empty()) {queue.pop();} + SerialDisposable sd; + { + std::unique_lock guard(lock); + while (!queue.empty()) {queue.pop();} + using std::swap; + swap(sd, this->sd); + observer= nullptr; + } sd.Dispose(); } operator Disposable() const @@ -319,7 +325,7 @@ namespace rxcpp sd.Set(sched->Schedule( [keepAlive](Scheduler::shared sched){ return keepAlive->Run(sched);})); - return Disposable::Empty(); + return sd; } // only decrement when no further work is scheduled @@ -341,13 +347,11 @@ namespace rxcpp std::atomic trampoline; mutable std::mutex lock; mutable std::condition_variable wake; - mutable std::atomic exit; CurrentThreadQueue::ThreadLocalQueue* queue; public: Derecurser() : trampoline(0) - , exit(false) { } virtual ~Derecurser() @@ -365,9 +369,12 @@ namespace rxcpp EnsureThreadResult result(util::maybe(), Disposable::Empty()); auto cancelable = std::make_shared(std::move(work)); + std::get<1>(result) = Disposable([cancelable]{ + *cancelable.get() = nullptr;}); std::unique_lock guard(lock); - RXCPP_UNWIND(unwindTrampoline, [&]{--trampoline;}); + RXCPP_UNWIND(unwindTrampoline, [&]{ + --trampoline;}); if (++trampoline == 1) { @@ -375,8 +382,6 @@ namespace rxcpp CurrentThreadQueue::DestroyQueue(queue); queue = nullptr;}); queue = CurrentThreadQueue::CreateQueue(owner).release(); - std::get<1>(result) = Disposable([cancelable]{ - *cancelable.get() = nullptr;}); queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); auto local = std::static_pointer_cast(shared_from_this()); @@ -390,8 +395,6 @@ namespace rxcpp } else { - std::get<1>(result) = Disposable([cancelable]{ - *cancelable.get() = nullptr;}); queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); wake.notify_one(); } @@ -402,7 +405,8 @@ namespace rxcpp void Run(CurrentThreadQueue::ThreadLocalQueue* queue) { auto keepAlive = shared_from_this(); { - RXCPP_UNWIND_AUTO([&]{--trampoline;}); + RXCPP_UNWIND_AUTO([&]{ + --trampoline;}); std::unique_lock guard(lock); @@ -411,37 +415,81 @@ namespace rxcpp CurrentThreadQueue::DestroyQueue(); queue = nullptr;}); - while(!exit && (!CurrentThreadQueue::empty() || trampoline > 1)) + auto start = queue->scheduler->Now(); + auto ms = std::chrono::milliseconds(1); + while(!CurrentThreadQueue::empty() || trampoline > 1) { + auto now = queue->scheduler->Now(); +#if 0 + {std::wstringstream out; + out << L"eventloop (run) pending: " << std::boolalpha << CurrentThreadQueue::empty() + << L", now: " << ((now - start) / ms); + if (!CurrentThreadQueue::empty()) { + out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} + out << std::endl; + OutputDebugString(out.str().c_str());} +#endif if (CurrentThreadQueue::empty()) { +#if 0 + {std::wstringstream out; + out << L"eventloop (wait for work) pending: " << std::boolalpha << CurrentThreadQueue::empty() + << L", now: " << ((now - start) / ms); + out << std::endl; + OutputDebugString(out.str().c_str());} +#endif wake.wait(guard, [&](){ - return exit || !CurrentThreadQueue::empty() || trampoline == 1;}); + return !CurrentThreadQueue::empty() || trampoline == 1;}); continue; } auto item = &CurrentThreadQueue::top(); - if (!item->work || !*item->work.get()) {CurrentThreadQueue::pop(); continue;} + if (!item->work || !*item->work.get()) { +#if 0 + {std::wstringstream out; + out << L"eventloop (pop disposed work) pending: " << std::boolalpha << CurrentThreadQueue::empty() + << L", now: " << ((now - start) / ms); + if (!CurrentThreadQueue::empty()) { + out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} + out << std::endl; + OutputDebugString(out.str().c_str());} +#endif + CurrentThreadQueue::pop(); continue;} // wait until the work is due - if (!exit && queue->scheduler->Now() < item->due) + if (now < item->due) { +#if 0 + {std::wstringstream out; + out << L"eventloop (wait for due) pending: " << std::boolalpha << CurrentThreadQueue::empty() + << L", now: " << ((now - start) / ms); + if (!CurrentThreadQueue::empty()) { + out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} + out << std::endl; + OutputDebugString(out.str().c_str());} +#endif wake.wait_until(guard, item->due); continue; } - if (exit || CurrentThreadQueue::empty()) {break;} - if (!item->work || !*item->work.get()) {CurrentThreadQueue::pop(); continue;} - +#if 0 + {std::wstringstream out; + out << L"eventloop (dispatch) pending: " << std::boolalpha << CurrentThreadQueue::empty() + << L", now: " << ((now - start) / ms); + if (!CurrentThreadQueue::empty()) { + out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} + out << std::endl; + OutputDebugString(out.str().c_str());} +#endif // dispatch work auto work = std::move(*item->work.get()); *item->work.get() = nullptr; CurrentThreadQueue::pop(); - RXCPP_UNWIND_AUTO([&]{guard.lock();}); + RXCPP_UNWIND_AUTO([&]{ + guard.lock();}); guard.unlock(); LocalScheduler::Do(work, queue->scheduler); } } - exit = false; } }; diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 7d64a1b..4af1b81 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -107,10 +107,11 @@ namespace rxcpp { namespace win32 { struct Queue; typedef std::pair Item; + typedef std::pair> PriorityItem; typedef std::priority_queue< - std::pair>, - std::vector>>, + PriorityItem, + std::vector, compare_work > ScheduledWork; @@ -157,18 +158,19 @@ namespace rxcpp { namespace win32 { static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { - static WindowClass* windowClass; + WindowClass* windowClass = reinterpret_cast(GetWindowLongPtr(hwnd, GWLP_USERDATA)); switch (message) { case WM_NCCREATE: { windowClass = reinterpret_cast(reinterpret_cast(lParam)->lpCreateParams); + SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast(reinterpret_cast(windowClass))); } break; case WM_NCDESTROY: { delete windowClass; - windowClass = nullptr; + SetWindowLongPtr(hwnd, GWLP_USERDATA, 0L); } break; case WM_TIMER: @@ -176,12 +178,14 @@ namespace rxcpp { namespace win32 { { bool destroy = false; HWND window = NULL; + std::vector> expired; { std::unique_lock guard(windowClass->queue->lock); while (!windowClass->queue->scheduledWork.empty() && !windowClass->queue->scheduledWork.top().second.get()->second) { // discard the disposed items + expired.push_back(windowClass->queue->scheduledWork.top().second); windowClass->queue->scheduledWork.pop(); } -- GitLab From 4fc2ba3977cf506ce2191f5cfd3898cef245a259 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 15 Jun 2013 17:00:49 -0700 Subject: [PATCH 039/782] fixes for error propagation --- Rx/CPP/src/cpprx/rx-operators.hpp | 467 +++++++++++++++++------------- Rx/CPP/testbench/testbench.cpp | 30 +- 2 files changed, 274 insertions(+), 223 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 1c726ca..4583adf 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -12,6 +12,68 @@ namespace rxcpp ////////////////////////////////////////////////////////////////////// // // constructors + template + struct CreatedAutoDetachObserver : public Observer + { + std::shared_ptr> observer; + SerialDisposable disposable; + + virtual ~CreatedAutoDetachObserver() { + clear(); + } + + virtual void OnNext(const T& element) + { + if (observer) { + RXCPP_UNWIND(disposer, [&](){ + disposable.Dispose(); + }); + observer->OnNext(element); + disposer.dismiss(); + } + } + virtual void OnCompleted() + { + if (observer) { + RXCPP_UNWIND(disposer, [&](){ + disposable.Dispose(); + }); + std::shared_ptr> final; + using std::swap; + swap(final, observer); + final->OnCompleted(); + disposer.dismiss(); + } + } + virtual void OnError(const std::exception_ptr& error) + { + if (observer) { + RXCPP_UNWIND(disposer, [&](){ + disposable.Dispose(); + }); + std::shared_ptr> final; + using std::swap; + swap(final, observer); + final->OnError(error); + disposer.dismiss(); + } + } + void clear() + { + observer = nullptr; + } + }; + + template + std::shared_ptr> CreateAutoDetachObserver( + std::shared_ptr> observer + ) + { + auto p = std::make_shared>(); + p->observer = std::move(observer); + + return p; + } template class CreatedObservable : public Observable @@ -25,25 +87,27 @@ namespace rxcpp } virtual Disposable Subscribe(std::shared_ptr> observer) { + auto autoDetachObserver = CreateAutoDetachObserver(std::move(observer)); + if (CurrentThreadScheduler::IsScheduleRequired()) { - SerialDisposable sd; auto scheduler = std::make_shared(); scheduler->Schedule( [=](Scheduler::shared) -> Disposable { try { - sd.Set(subscribe(observer)); + autoDetachObserver->disposable.Set(subscribe(autoDetachObserver)); } catch (...) { - observer->OnError(std::current_exception()); + autoDetachObserver->OnError(std::current_exception()); } return Disposable::Empty(); } ); - return sd; + return autoDetachObserver->disposable; } try { - return subscribe(observer); + autoDetachObserver->disposable.Set(subscribe(autoDetachObserver)); + return autoDetachObserver->disposable; } catch (...) { - observer->OnError(std::current_exception()); + autoDetachObserver->OnError(std::current_exception()); } return Disposable::Empty(); } @@ -68,33 +132,32 @@ namespace rxcpp virtual void OnNext(const T& element) { - try - { - if(onNext) - { - onNext(element); - } - } - catch (...) + if(onNext) { - OnError(std::current_exception()); + onNext(element); } } virtual void OnCompleted() { if(onCompleted) { - onCompleted(); - } - clear(); + std::function final; + using std::swap; + swap(final, onCompleted); + clear(); + final(); + } } virtual void OnError(const std::exception_ptr& error) { if(onError) { - onError(error); + std::function final; + using std::swap; + swap(final, onError); + clear(); + final(error); } - clear(); } void clear() { @@ -119,6 +182,14 @@ namespace rxcpp return p; } + struct SubjectState { + enum type { + Invalid, + Forwarding, + Completed, + Error + }; + }; template class ObservableSubject : @@ -127,6 +198,8 @@ namespace rxcpp { protected: std::mutex lock; + SubjectState::type state; + std::exception_ptr error; std::vector>> observers; virtual ~ObservableSubject() { @@ -139,6 +212,9 @@ namespace rxcpp swap(observers, empty); } + ObservableSubject() : state(SubjectState::Forwarding) { + } + void RemoveObserver(std::shared_ptr> toRemove) { std::unique_lock guard(lock); @@ -162,16 +238,24 @@ namespace rxcpp { std::unique_lock guard(lock); - for(auto& o : observers) - { - if (!o){ - o = std::move(observer); - return d; + if (state == SubjectState::Completed) { + observer->OnCompleted(); + return Disposable::Empty(); + } else if (state == SubjectState::Error) { + observer->OnError(error); + return Disposable::Empty(); + } else { + for(auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } } + observers.push_back(std::move(observer)); + return d; } - observers.push_back(std::move(observer)); } - return d; } }; @@ -193,22 +277,15 @@ namespace rxcpp guard.unlock(); for(auto& o : local) { - try - { - if (o) { - o->OnNext(element); - } - } - catch (...) - { - o->OnError(std::current_exception()); - Base::RemoveObserver(o); + if (o) { + o->OnNext(element); } } } virtual void OnCompleted() { std::unique_lock guard(Base::lock); + Base::state = SubjectState::Completed; auto local = std::move(Base::observers); guard.unlock(); for(auto& o : local) @@ -221,6 +298,8 @@ namespace rxcpp virtual void OnError(const std::exception_ptr& error) { std::unique_lock guard(Base::lock); + Base::state = SubjectState::Error; + Base::error = error; auto local = std::move(Base::observers); guard.unlock(); for(auto& o : local) @@ -278,6 +357,8 @@ namespace rxcpp { std::mutex lock; T value; + SubjectState::type state; + std::exception_ptr error; std::vector>> observers; void RemoveObserver(std::shared_ptr> toRemove) @@ -291,7 +372,7 @@ namespace rxcpp BehaviorSubject(); public: - explicit BehaviorSubject(T t) : value(std::move(t)) {} + explicit BehaviorSubject(T t) : value(std::move(t)), state(SubjectState::Forwarding) {} virtual ~BehaviorSubject() { // putting this first means that the observers @@ -315,10 +396,15 @@ namespace rxcpp } }); - try { - { - std::unique_lock guard(lock); + std::unique_lock guard(lock); + if (state == SubjectState::Completed) { + observer->OnCompleted(); + return Disposable::Empty(); + } else if (state == SubjectState::Error) { + observer->OnError(error); + return Disposable::Empty(); + } else { for(auto& o : observers) { if (!o){ @@ -328,12 +414,9 @@ namespace rxcpp } observers.push_back(observer); } - observer->OnNext(value); } - catch (...) - { - observer->OnError(std::current_exception()); - RemoveObserver(observer); + if (state == SubjectState::Forwarding) { + observer->OnNext(value); } return d; @@ -347,22 +430,15 @@ namespace rxcpp guard.unlock(); for(auto& o : local) { - try - { - if (o) { - o->OnNext(value); - } - } - catch (...) - { - o->OnError(std::current_exception()); - RemoveObserver(o); + if (o) { + o->OnNext(value); } } } virtual void OnCompleted() { std::unique_lock guard(lock); + state = SubjectState::Completed; auto local = std::move(observers); guard.unlock(); for(auto& o : local) @@ -372,9 +448,11 @@ namespace rxcpp } } } - virtual void OnError(const std::exception_ptr& error) + virtual void OnError(const std::exception_ptr& errorArg) { std::unique_lock guard(lock); + state = SubjectState::Error; + error = errorArg; auto local = std::move(observers); guard.unlock(); for(auto& o : local) @@ -439,24 +517,20 @@ namespace rxcpp cd.Add(scheduler->Schedule( fix0([=](Scheduler::shared s, std::function self) -> Disposable { - try { - if (state->cancel) - return Disposable::Empty(); + if (state->cancel) + return Disposable::Empty(); - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - state->i += step; - return s->Schedule(std::move(self)); - } - } catch (...) { - observer->OnError(std::current_exception()); - } + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + state->i += step; + return s->Schedule(std::move(self)); + } return Disposable::Empty(); }))); @@ -553,23 +627,19 @@ namespace rxcpp cd.Add(scheduler->Schedule( fix0([=](Scheduler::shared s, std::function self) -> Disposable { - try { - if (state->cancel) - return Disposable::Empty(); + if (state->cancel) + return Disposable::Empty(); - if (state->r_cursor == state->r_end) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(*state->r_cursor); - ++state->r_cursor; - return s->Schedule(std::move(self)); - } - } catch (...) { - observer->OnError(std::current_exception()); - } + if (state->r_cursor == state->r_end) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(*state->r_cursor); + ++state->r_cursor; + return s->Schedule(std::move(self)); + } return Disposable::Empty(); }))); @@ -710,54 +780,9 @@ namespace rxcpp if (!cancel) ++state->subscribed; } if (!cancel) { + decltype(collectionSelector(sourceElement)) collection; try { - auto collection = collectionSelector(sourceElement); - cd.Add(Subscribe( - collection, - // on next - [=](const CI& collectionElement) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - try { - if (!cancel) { - auto result = resultSelector(sourceElement, collectionElement); - observer->OnNext(std::move(result)); - } - } catch (...) { - observer->OnError(std::current_exception()); - cd.Dispose(); - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - { - std::unique_lock guard(state->lock); - finished = (--state->subscribed) == 0; - cancel = state->cancel; - } - if (!cancel && finished) - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - --state->subscribed; - cancel = state->cancel; - } - if (!cancel) - observer->OnError(error); - cd.Dispose(); - })); + collection = collectionSelector(sourceElement); } catch (...) { bool cancel = false; { @@ -769,6 +794,53 @@ namespace rxcpp } cd.Dispose(); } + cd.Add(Subscribe( + collection, + // on next + [=](const CI& collectionElement) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + decltype(resultSelector(sourceElement, collectionElement)) result; + try { + result = resultSelector(sourceElement, collectionElement); + } catch (...) { + observer->OnError(std::current_exception()); + cd.Dispose(); + } + observer->OnNext(std::move(result)); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + finished = (--state->subscribed) == 0; + cancel = state->cancel; + } + if (!cancel && finished) + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + --state->subscribed; + cancel = state->cancel; + } + if (!cancel) + observer->OnError(error); + cd.Dispose(); + })); } }, // on completed @@ -855,78 +927,61 @@ namespace rxcpp sd.Set(sched->Schedule( fix0([state, cd, sd, observer](Scheduler::shared s, std::function self) -> Disposable { - try { - bool cancel = false; - bool finished = false; - ObservableT next; - { - std::unique_lock guard(state->lock); - finished = state->queue.empty(); - cancel = state->cancel; - if (!cancel && !finished) {next = state->queue.front(); state->queue.pop();} - } - if (!cancel && !finished) { - sd.Set(Subscribe( - next, - // on next - [=](const T& t) + bool cancel = false; + bool finished = false; + ObservableT next; + { + std::unique_lock guard(state->lock); + finished = state->queue.empty(); + cancel = state->cancel; + if (!cancel && !finished) {next = state->queue.front(); state->queue.pop();} + } + if (!cancel && !finished) { + sd.Set(Subscribe( + next, + // on next + [=](const T& t) + { + bool cancel = false; { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - try { - if (!cancel) { - observer->OnNext(std::move(t)); - } - } catch (...) { - observer->OnError(std::current_exception()); - cd.Dispose(); - } - }, - // on completed - [=] + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnNext(std::move(t)); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + bool subscribe = false; { - bool cancel = false; - bool finished = false; - bool subscribe = false; - { - std::unique_lock guard(state->lock); - finished = state->queue.empty() && state->completed; - subscribe = !state->queue.empty(); - state->subscribed = subscribe; - cancel = state->cancel; - } - if (!cancel) { - if (subscribe) {sd.Set(s->Schedule(std::move(self)));} - else if (finished) {observer->OnCompleted(); cd.Dispose();} - } - }, - // on error - [=](const std::exception_ptr& error) + std::unique_lock guard(state->lock); + finished = state->queue.empty() && state->completed; + subscribe = !state->queue.empty(); + state->subscribed = subscribe; + cancel = state->cancel; + } + if (!cancel) { + if (subscribe) {sd.Set(s->Schedule(std::move(self)));} + else if (finished) {observer->OnCompleted(); cd.Dispose();} + } + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); - })); - } - } catch (...) { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + })); } return Disposable::Empty(); }))); diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index a610c67..a0ace60 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -468,23 +468,19 @@ std::shared_ptr> Data( cd.Add(scheduler->Schedule( rxcpp::fix0([=](rxcpp::Scheduler::shared s, std::function self) -> rxcpp::Disposable { - try { - if (state->cancel) - return rxcpp::Disposable::Empty(); - - string line; - if (!!getline(state->data, line)) - { - observer->OnNext(std::move(line)); - return s->Schedule(std::move(self)); - } - else - { - observer->OnCompleted(); - } - } catch (...) { - observer->OnError(std::current_exception()); - } + if (state->cancel) + return rxcpp::Disposable::Empty(); + + string line; + if (!!getline(state->data, line)) + { + observer->OnNext(std::move(line)); + return s->Schedule(std::move(self)); + } + else + { + observer->OnCompleted(); + } return rxcpp::Disposable::Empty(); }) )); -- GitLab From 674bd2437fd527df2184e64ece3d64f94fc5bc45 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 17 Jun 2013 00:44:29 -0700 Subject: [PATCH 040/782] error fixes - phase 2 --- Rx/CPP/src/cpprx/rx-base.hpp | 9 +- Rx/CPP/src/cpprx/rx-operators.hpp | 248 ++++++++++++++++++------------ Rx/CPP/src/cpprx/rx-scheduler.hpp | 9 +- Rx/CPP/src/cpprx/rx-util.hpp | 8 +- Rx/CPP/testbench/testbench.cpp | 35 +++-- 5 files changed, 191 insertions(+), 118 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 571f482..e50ba13 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -204,7 +204,7 @@ namespace rxcpp auto local = std::move(scheduler); if (local) { auto keepAlive = shared_from_this(); - local->Schedule([keepAlive] (Scheduler::shared) { + local->Schedule([keepAlive] (Scheduler::shared) -> Disposable { keepAlive->disposable.Dispose(); return Disposable::Empty(); }); @@ -414,6 +414,7 @@ namespace rxcpp template struct is_observable>> {static const bool value = true;}; +namespace detail { template struct observable_item; @@ -422,6 +423,12 @@ namespace rxcpp template struct observable_item>> {typedef T type;}; +} + template + struct observable_item + { + typedef typename detail::observable_item::type>::type type; + }; template struct observable_observer; diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 4583adf..eaf8373 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -566,7 +566,7 @@ namespace rxcpp auto keepAlive = this->shared_from_this(); sd.Set(s->Schedule( last, - [this, keepAlive] (Scheduler::shared s){ + [this, keepAlive] (Scheduler::shared s) -> Disposable { Tick(s); return Disposable::Empty(); } @@ -578,7 +578,7 @@ namespace rxcpp state->last += state->due; state->sd.Set(scheduler->Schedule( state->last, - [=] (Scheduler::shared s){ + [=] (Scheduler::shared s) -> Disposable { state->Tick(s); return Disposable::Empty(); } @@ -717,8 +717,15 @@ namespace rxcpp // on next [=](const T& element) { - auto result = selector(element); - observer->OnNext(std::move(result)); + util::maybe result; + try { + result.set(selector(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + observer->OnNext(std::move(*result.get())); + } }, // on completed [=] @@ -780,10 +787,10 @@ namespace rxcpp if (!cancel) ++state->subscribed; } if (!cancel) { - decltype(collectionSelector(sourceElement)) collection; + util::maybe collection; try { - collection = collectionSelector(sourceElement); - } catch (...) { + collection.set(collectionSelector(sourceElement)); + } catch(...) { bool cancel = false; { std::unique_lock guard(state->lock); @@ -794,53 +801,57 @@ namespace rxcpp } cd.Dispose(); } - cd.Add(Subscribe( - collection, - // on next - [=](const CI& collectionElement) - { - bool cancel = false; + if (!!collection) { + cd.Add(Subscribe( + *collection.get(), + // on next + [=](const CI& collectionElement) { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - decltype(resultSelector(sourceElement, collectionElement)) result; - try { - result = resultSelector(sourceElement, collectionElement); - } catch (...) { - observer->OnError(std::current_exception()); - cd.Dispose(); + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; } - observer->OnNext(std::move(result)); - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; + if (!cancel) { + util::maybe result; + try { + result.set(resultSelector(sourceElement, collectionElement)); + } catch(...) { + observer->OnError(std::current_exception()); + cd.Dispose(); + } + if (!!result) { + observer->OnNext(std::move(*result.get())); + } + } + }, + // on completed + [=] { - std::unique_lock guard(state->lock); - finished = (--state->subscribed) == 0; - cancel = state->cancel; - } - if (!cancel && finished) - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + finished = (--state->subscribed) == 0; + cancel = state->cancel; + } + if (!cancel && finished) + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) { - std::unique_lock guard(state->lock); - --state->subscribed; - cancel = state->cancel; - } - if (!cancel) - observer->OnError(error); - cd.Dispose(); - })); + bool cancel = false; + { + std::unique_lock guard(state->lock); + --state->subscribed; + cancel = state->cancel; + } + if (!cancel) + observer->OnError(error); + cd.Dispose(); + })); + } } }, // on completed @@ -1034,7 +1045,6 @@ namespace rxcpp // on next [=](const typename std::tuple_element::type& element) { - static bool pending = true; auto local = state; std::unique_lock guard(local->lock); std::get(local->latest) = element; @@ -1044,14 +1054,22 @@ namespace rxcpp } if (local->pendingFirst == 0) { Latest args = local->latest; - auto result = util::tuple_dispatch(local->selector, args); - ++state->pendingIssue; - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(result)); + typedef decltype(util::tuple_dispatch(local->selector, args)) U; + util::maybe result; + try { + result.set(util::tuple_dispatch(local->selector, args)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + ++state->pendingIssue; + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(*result.get())); + } + --state->pendingIssue; } - --state->pendingIssue; if (state->done && state->pendingIssue == 0) { guard.unlock(); observer->OnCompleted(); @@ -1221,14 +1239,22 @@ namespace rxcpp // cause side-effect of pop on each queue std::make_tuple((queue.pop(), true)...); - ++state->pending; - auto result = util::tuple_dispatch(state->selector, args); - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(result)); + typedef decltype(util::tuple_dispatch(state->selector, args)) U; + util::maybe result; + try { + result.set(util::tuple_dispatch(state->selector, args)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + ++state->pending; + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(*result.get())); + } + --state->pending; } - --state->pending; } // build new array to check for any empty queue bool post_empties[] = {queue.empty()...}; @@ -1257,14 +1283,22 @@ namespace rxcpp queue1.pop(); queue2.pop(); - ++state->pending; - auto result = util::tuple_dispatch(state->selector, args); - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(result)); + typedef decltype(util::tuple_dispatch(state->selector, args)) U; + util::maybe result; + try { + result.set(util::tuple_dispatch(state->selector, args)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + ++state->pending; + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(*result.get())); + } + --state->pending; } - --state->pending; } // build new array to check for any empty queue bool post_empties[] = {queue1.empty(), queue2.empty()}; @@ -1520,8 +1554,14 @@ namespace rxcpp // on next [=](const T& element) { - auto result = predicate(element); - if (result) + typedef decltype(predicate(element)) U; + util::maybe result; + try { + result.set(predicate(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result && *result.get()) { observer->OnNext(element); } @@ -1555,7 +1595,7 @@ namespace rxcpp typedef std::shared_ptr> LocalGroupObservable; return CreateObservable( - [=](std::shared_ptr> observer) + [=](std::shared_ptr> observer) -> Disposable { typedef std::map>, L> Groups; @@ -1572,26 +1612,42 @@ namespace rxcpp // on next [=](const T& element) { - auto key = keySelector(element); - auto keySubject = CreateGroupedSubject(key); + util::maybe key; + try { + key.set(keySelector(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } - typename Groups::iterator groupIt; - bool newGroup = false; + if (!!key) { + auto keySubject = CreateGroupedSubject(*key.get()); - { - std::unique_lock guard(state->lock); - std::tie(groupIt, newGroup) = state->groups.insert( - std::make_pair(key,keySubject) - ); - } + typename Groups::iterator groupIt; + bool newGroup = false; - if (newGroup) - { - LocalGroupObservable nextGroup(std::move(keySubject)); - observer->OnNext(nextGroup); + { + std::unique_lock guard(state->lock); + std::tie(groupIt, newGroup) = state->groups.insert( + std::make_pair(*key.get(), keySubject) + ); + } + + if (newGroup) + { + LocalGroupObservable nextGroup(std::move(keySubject)); + observer->OnNext(nextGroup); + } + + util::maybe result; + try { + result.set(valueSelector(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + groupIt->second->OnNext(std::move(*result.get())); + } } - auto result = valueSelector(element); - groupIt->second->OnNext(std::move(result)); }, // on completed [=] @@ -1873,7 +1929,7 @@ namespace rxcpp { typedef typename StdCollection::value_type Value; return CreateObservable( - [=](std::shared_ptr> observer) + [=](std::shared_ptr> observer) -> Disposable { auto stdCollection = std::make_shared(); return Subscribe( @@ -1928,7 +1984,7 @@ namespace rxcpp { auto sched_disposable = scheduler->Schedule( due, - [=] (Scheduler::shared){ + [=] (Scheduler::shared) -> Disposable { if (!*cancel) observer->OnNext(element); return Disposable::Empty(); @@ -1945,7 +2001,7 @@ namespace rxcpp { auto sched_disposable = scheduler->Schedule( due, - [=](Scheduler::shared){ + [=](Scheduler::shared) -> Disposable { if (!*cancel) observer->OnCompleted(); return Disposable::Empty(); @@ -2005,7 +2061,7 @@ namespace rxcpp } sd.Set(scheduler->Schedule( due, - [=] (Scheduler::shared){ + [=] (Scheduler::shared) -> Disposable { { std::unique_lock guard(state->lock); if (state->hasValue && state->id == current) { @@ -2154,7 +2210,7 @@ namespace rxcpp SerialDisposable sd; cd.Add(sd); - cd.Add(scheduler->Schedule([=](Scheduler::shared){ + cd.Add(scheduler->Schedule([=](Scheduler::shared) -> Disposable { sd.Set(ScheduledDisposable(scheduler, source->Subscribe(observer))); return Disposable::Empty(); })); diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 2757acd..2a3a5fc 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -238,8 +238,8 @@ namespace rxcpp public: ScheduledObserver(Scheduler::shared scheduler, std::shared_ptr> observer) : scheduler(std::move(scheduler)) - , observer(std::move(observer)) , trampoline(0) + , observer(std::move(observer)) { } @@ -414,9 +414,10 @@ namespace rxcpp RXCPP_UNWIND(unwindQueue, [&](){ CurrentThreadQueue::DestroyQueue(); queue = nullptr;}); - +#if 0 auto start = queue->scheduler->Now(); auto ms = std::chrono::milliseconds(1); +#endif while(!CurrentThreadQueue::empty() || trampoline > 1) { auto now = queue->scheduler->Now(); @@ -508,8 +509,8 @@ namespace rxcpp } template EventLoopScheduler(Factory factoryarg) - : derecurser(std::make_shared()) - , factory(std::move(factoryarg)) + : factory(std::move(factoryarg)) + , derecurser(std::make_shared()) { } virtual ~EventLoopScheduler() diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index a7f2a23..5d78098 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -447,16 +447,16 @@ namespace rxcpp { namespace util { struct pass_through { template - X operator()(X x) {return std::move(x);} + typename std::decay::type operator()(X&& x) {return std::forward(x);} template - X operator()(X x) const {return std::move(x);} + typename std::decay::type operator()(X&& x) const {return std::forward(x);} }; struct pass_through_second { template - Y operator()(X , Y y) {return std::move(y);} + typename std::decay::type operator()(X&& , Y&& y) {return std::forward(y);} template - Y operator()(X , Y y) const {return std::move(y);} + typename std::decay::type operator()(X&& , Y&& y) const {return std::forward(y);} }; template diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index a0ace60..79f97e4 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -69,7 +69,7 @@ void Concat(int n) auto s1 = rxcpp::from(values1) .subscribe_on(input1) .where(IsPrime) - .select([](int prime){this_thread::yield(); return std::make_tuple("1:", prime);}) + .select([](int prime) -> std::tuple {this_thread::yield(); return std::make_tuple("1:", prime);}) .take(n/2) .publish(); @@ -77,7 +77,7 @@ void Concat(int n) auto s2 = rxcpp::from(values2) .subscribe_on(input2) .where(IsPrime) - .select([](int prime){this_thread::yield(); return std::make_tuple("2:", prime);}) + .select([](int prime) -> std::tuple {this_thread::yield(); return std::make_tuple("2:", prime);}) .take(n/2) .publish(); @@ -101,14 +101,14 @@ void Combine(int n) auto s1 = rxcpp::from(values1) .subscribe_on(input1) .where(IsPrime) - .select([](int prime){this_thread::yield(); return prime;}) + .select([](int prime) -> int {this_thread::yield(); return prime;}) .publish(); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers rxcpp::from(values2) .subscribe_on(input2) .where(IsPrime) - .select([](int prime){this_thread::yield(); return prime;}) + .select([](int prime) -> int {this_thread::yield(); return prime;}) .combine_latest(s1) .take(n) .observe_on(output) @@ -132,7 +132,7 @@ std::shared_ptr> Record( ) { return rxcpp::CreateObservable( - [=](std::shared_ptr> observer) + [=](std::shared_ptr> observer) -> rxcpp::Disposable { rxcpp::ComposableDisposable cd; cd.Add(rxcpp::Disposable([=](){ @@ -180,7 +180,7 @@ void Zip(int n) .subscribe_on(input1) .where(IsPrime) .template chain(&s1count) - .select([](int prime){this_thread::yield(); return prime;}) + .select([](int prime) -> int {this_thread::yield(); return prime;}) .publish(); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers @@ -188,7 +188,7 @@ void Zip(int n) .subscribe_on(input2) .where(IsPrime) .template chain(&s2count) - .select([](int prime){this_thread::yield(); return prime;}) + .select([](int prime) -> int {this_thread::yield(); return prime;}) .zip(s1) .template chain(&zipcount) .take(n) @@ -220,14 +220,14 @@ void Merge(int n) auto s1 = rxcpp::from(values1) .subscribe_on(input1) .where(IsPrime) - .select([](int prime1) {this_thread::yield(); return std::make_tuple("1: ", prime1);}) + .select([](int prime1) -> std::tuple {this_thread::yield(); return std::make_tuple("1: ", prime1);}) .publish(); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers rxcpp::from(values2) .subscribe_on(input2) .where(IsPrime) - .select([](int prime2) {this_thread::yield(); return std::make_tuple("2: ", prime2);}) + .select([](int prime2) -> std::tuple {this_thread::yield(); return std::make_tuple("2: ", prime2);}) .merge(s1) .take(n) .observe_on(output) @@ -294,11 +294,22 @@ void run() int concurrency; double time; + item(const item& other) : args(other.args), concurrency(other.concurrency), time(other.time) { + } + item(item&& other) : args(std::move(other.args)), concurrency(std::move(other.concurrency)), time(std::move(other.time)) { + } item(const string& input) { args = extract_value(input, "args"); concurrency = atoi( extract_value(input, "concurrency").c_str() ); time = atof( extract_value(input, "time").c_str() ); } + item& operator=(item other){ + using std::swap; + swap(args, other.args); + swap(concurrency, other.concurrency); + swap(time, other.time); + return *this; + } }; auto input = std::make_shared(); @@ -306,8 +317,6 @@ void run() auto dataLines = Data("data.txt"); - int arggroupcount = 0; - rxcpp::from(dataLines) .subscribe_on(input) // parse input into items @@ -373,10 +382,10 @@ template void innerScheduler() { auto outer = std::make_shared(); rxcpp::Scheduler::shared inner; - outer->Schedule([&](rxcpp::Scheduler::shared s){ + outer->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { inner = s; return rxcpp::Disposable::Empty();}); while(!inner); - inner->Schedule([&](rxcpp::Scheduler::shared s){ + inner->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { inner = nullptr; return rxcpp::Disposable::Empty();}); while(!!inner); cout << "innerScheduler test succeeded" << endl; -- GitLab From 27a38f93b45b4e5065c26fb630a3e9173d7caab2 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 17 Jun 2013 21:36:22 -0700 Subject: [PATCH 041/782] clang warning --- Ix/CPP/src/cpplinq/linq_cursor.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Ix/CPP/src/cpplinq/linq_cursor.hpp b/Ix/CPP/src/cpplinq/linq_cursor.hpp index 827c488..8c95371 100644 --- a/Ix/CPP/src/cpplinq/linq_cursor.hpp +++ b/Ix/CPP/src/cpplinq/linq_cursor.hpp @@ -177,16 +177,16 @@ namespace cpplinq { iter_cursor(Iterator start, Iterator fin) - : start(start) + : current(start) + , start(start) , fin(std::move(fin)) - , current(start) { } iter_cursor(Iterator start, Iterator fin, Iterator current) - : start(std::move(start)) + : current(std::move(current)) + , start(std::move(start)) , fin(std::move(fin)) - , current(std::move(current)) { } -- GitLab From fd9e17d2db79fc6a9b355269bd5d206a7aba9cf9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 18 Jun 2013 09:39:34 -0700 Subject: [PATCH 042/782] pushing min/max macros don't need to wrap push_macro/pop_macro in ifdefs because gcc, clang and msvc support them. --- Ix/CPP/src/cpplinq/linq.hpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Ix/CPP/src/cpplinq/linq.hpp b/Ix/CPP/src/cpplinq/linq.hpp index 2d7c1e7..5f08588 100644 --- a/Ix/CPP/src/cpplinq/linq.hpp +++ b/Ix/CPP/src/cpplinq/linq.hpp @@ -129,6 +129,11 @@ #define CPPLINQ_LINQ_HPP #pragma once +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + #include #include #include @@ -542,5 +547,8 @@ linq_driver from_value(const TContainer& c) } +#pragma pop_macro("min") +#pragma pop_macro("max") + #endif // defined(CPPLINQ_LINQ_HPP) -- GitLab From 7de88ea358cdc92a7dedbf3cf3fdac4a6eb17c57 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 18 Jun 2013 09:40:15 -0700 Subject: [PATCH 043/782] inline non-template func def in header --- Rx/CPP/src/cpprx/rx-operators.hpp | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index eaf8373..3bf908a 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -538,7 +538,7 @@ namespace rxcpp }); } - std::shared_ptr> Interval( + inline std::shared_ptr> Interval( Scheduler::clock::duration due, Scheduler::shared scheduler) { @@ -675,16 +675,20 @@ namespace rxcpp std::condition_variable wake; bool done = false; std::exception_ptr error; - auto observer = CreateObserver(std::move(onNext), [&]{ - std::unique_lock guard(lock); - done = true; - wake.notify_one(); - }, [&](const std::exception_ptr& e){ - std::unique_lock guard(lock); - done = true; - error = std::move(e); - wake.notify_one(); - }); + auto observer = CreateObserver(std::move(onNext), + //on completed + [&]{ + std::unique_lock guard(lock); + done = true; + wake.notify_one(); + }, + //on error + [&](const std::exception_ptr& e){ + std::unique_lock guard(lock); + done = true; + error = std::move(e); + wake.notify_one(); + }); source->Subscribe(observer); -- GitLab From 0e83c84051a245667554321c16f3bff7977d3c5d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Jun 2013 14:15:59 -0700 Subject: [PATCH 044/782] remove publish --- Rx/CPP/src/cpprx/rx.hpp | 71 +++++++++++++++++++++------------- Rx/CPP/testbench/testbench.cpp | 23 ++++------- 2 files changed, 53 insertions(+), 41 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index a083904..acdf2eb 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -8,11 +8,24 @@ namespace rxcpp { + template + class Binder; + + template + class Binder>; + +namespace detail { + template + struct observable_item> {typedef typename rxcpp::observable_item::type type;}; +} + template class BinderBase { protected: Obj obj; + template + friend V rxcpp::observable(const BinderBase& b); public: typedef T item_type; @@ -21,8 +34,17 @@ namespace rxcpp BinderBase(Obj obj) : obj(std::move(obj)) { } + + Observable* operator->() const { + return obj.get(); + } }; + template + Obj observable(const BinderBase& b) { + return b.obj; + } + template class BinderNested; @@ -66,7 +88,7 @@ namespace rxcpp return from(Concat(obj)); } }; - + template class Binder : public BinderNested< typename observable_item::type, @@ -103,60 +125,60 @@ namespace rxcpp #if RXCPP_USE_VARIADIC_TEMPLATES template auto merge(const MergeSource&... source) - -> decltype(from(Merge(obj, source...))) { - return from(Merge(obj, source...)); + -> decltype(from(Merge(obj, observable(source)...))) { + return from(Merge(obj, observable(source)...)); } #else template auto merge(const MergeSource& source) - -> decltype(from(Merge(obj, source))) { - return from(Merge(obj, source)); + -> decltype(from(Merge(obj, observable(source)))) { + return from(Merge(obj, observable(source))); } #endif //RXCPP_USE_VARIADIC_TEMPLATES #if RXCPP_USE_VARIADIC_TEMPLATES template auto zip(S selector, const ZipSource&... source) - -> decltype(from(Zip(selector, obj, source...))) { - return from(Zip(selector, obj, source...)); + -> decltype(from(Zip(selector, obj, observable(source)...))) { + return from(Zip(selector, obj, observable(source)...)); } template auto zip(const Zip1Source&... source) - -> decltype(from(Zip(util::as_tuple(), obj, source...))) { - return from(Zip(util::as_tuple(), obj, source...)); + -> decltype(from(Zip(util::as_tuple(), obj, observable(source)...))) { + return from(Zip(util::as_tuple(), obj, observable(source)...)); } #else template auto zip(S selector, const ZipSource& source) - -> decltype(from(Zip(selector, obj, source))) { - return from(Zip(selector, obj, source)); + -> decltype(from(Zip(selector, obj, observable(source)))) { + return from(Zip(selector, obj, observable(source))); } template auto zip(const Zip1Source& source) - -> decltype(from(Zip(util::as_tuple(), obj, source))) { - return from(Zip(util::as_tuple(), obj, source)); + -> decltype(from(Zip(util::as_tuple(), obj, observable(source)))) { + return from(Zip(util::as_tuple(), obj, observable(source))); } #endif //RXCPP_USE_VARIADIC_TEMPLATES #if RXCPP_USE_VARIADIC_TEMPLATES template auto combine_latest(S selector, const CombineLSource&... source) - -> decltype(from(CombineLatest(selector, obj, source...))) { - return from(CombineLatest(selector, obj, source...)); + -> decltype(from(CombineLatest(selector, obj, observable(source)...))) { + return from(CombineLatest(selector, obj, observable(source)...)); } template auto combine_latest(const CombineL1Source&... source) - -> decltype(from(CombineLatest(util::as_tuple(), obj, source...))) { - return from(CombineLatest(util::as_tuple(), obj, source...)); + -> decltype(from(CombineLatest(util::as_tuple(), obj, observable(source)...))) { + return from(CombineLatest(util::as_tuple(), obj, observable(source)...)); } #else template auto combine_latest(S selector, const CombineLSource& source) - -> decltype(from(CombineLatest(selector, obj, source))) { - return from(CombineLatest(selector, obj, source)); + -> decltype(from(CombineLatest(selector, obj, observable(source)))) { + return from(CombineLatest(selector, obj, observable(source))); } template auto combine_latest(const CombineLSource& source) - -> decltype(from(CombineLatest(util::as_tuple(), obj, source))) { - return from(CombineLatest(util::as_tuple(), obj, source)); + -> decltype(from(CombineLatest(util::as_tuple(), obj, observable(source)))) { + return from(CombineLatest(util::as_tuple(), obj, observable(source))); } #endif //RXCPP_USE_VARIADIC_TEMPLATES @@ -167,7 +189,7 @@ namespace rxcpp -> decltype(from(Concat(Iterate(std::vector())))) { std::vector sources; sources.push_back(obj); - std::make_tuple((sources.push_back(source), true)...); + std::make_tuple((sources.push_back(observable(source)), true)...); return from(Concat(Iterate(std::move(sources)))); } #else @@ -175,7 +197,7 @@ namespace rxcpp -> decltype(from(Concat(Iterate(std::vector())))) { std::vector sources; sources.push_back(obj); - sources.push_back(source); + sources.push_back(observable(source)); return from(Concat(Iterate(std::move(sources)))); } #endif //RXCPP_USE_VARIADIC_TEMPLATES @@ -189,9 +211,6 @@ namespace rxcpp auto where(P predicate) -> decltype(from(Where(obj, predicate))) { return from(Where(obj, predicate)); } - Obj publish() { - return obj; - } template auto group_by( KS keySelector) diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 79f97e4..770db93 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -70,16 +70,14 @@ void Concat(int n) .subscribe_on(input1) .where(IsPrime) .select([](int prime) -> std::tuple {this_thread::yield(); return std::make_tuple("1:", prime);}) - .take(n/2) - .publish(); + .take(n/2); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers auto s2 = rxcpp::from(values2) .subscribe_on(input2) .where(IsPrime) .select([](int prime) -> std::tuple {this_thread::yield(); return std::make_tuple("2:", prime);}) - .take(n/2) - .publish(); + .take(n/2); rxcpp::from(s2) .concat(s1) @@ -101,8 +99,7 @@ void Combine(int n) auto s1 = rxcpp::from(values1) .subscribe_on(input1) .where(IsPrime) - .select([](int prime) -> int {this_thread::yield(); return prime;}) - .publish(); + .select([](int prime) -> int {this_thread::yield(); return prime;}); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers rxcpp::from(values2) @@ -180,8 +177,7 @@ void Zip(int n) .subscribe_on(input1) .where(IsPrime) .template chain(&s1count) - .select([](int prime) -> int {this_thread::yield(); return prime;}) - .publish(); + .select([](int prime) -> int {this_thread::yield(); return prime;}); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers rxcpp::from(values2) @@ -220,8 +216,7 @@ void Merge(int n) auto s1 = rxcpp::from(values1) .subscribe_on(input1) .where(IsPrime) - .select([](int prime1) -> std::tuple {this_thread::yield(); return std::make_tuple("1: ", prime1);}) - .publish(); + .select([](int prime1) -> std::tuple {this_thread::yield(); return std::make_tuple("1: ", prime1);}); auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers rxcpp::from(values2) @@ -250,7 +245,7 @@ void PrintIntervals(int n) { cout << n << " Intervals of .5 second: " << endl; rxcpp::from(subject) - .zip(rxcpp::from(subject).skip(1).publish()) + .zip(rxcpp::from(subject).skip(1)) .select(rxcpp::MakeTupleDispatch( [=](Tick a, Tick b){ return duration_cast(b.at.time_since_epoch()) - @@ -341,14 +336,12 @@ void run() return rxcpp::from(concurrencyGroup) .select([](const item& i){ return i.time;}) - .to_vector() - .publish();}, + .to_vector();}, [](const std::shared_ptr> & concurrencyGroup, const std::vector & times){ return std::make_tuple(concurrencyGroup->Key(), times);} ) - .to_vector() - .publish();}, + .to_vector();}, [](const std::shared_ptr> & argsGroup, const std::vector>> & ouputGroup){ return std::make_tuple(argsGroup->Key(), ouputGroup);} -- GitLab From 19d503563c8c5c18de17802051dab8a32b8e6ee2 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Jun 2013 23:13:32 -0700 Subject: [PATCH 045/782] fix test using condition_variable --- Rx/CPP/testbench/testbench.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 770db93..718a347 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -375,12 +375,17 @@ template void innerScheduler() { auto outer = std::make_shared(); rxcpp::Scheduler::shared inner; + std::mutex lock; + std::unique_lock guard(lock); + std::condition_variable wake; outer->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { - inner = s; return rxcpp::Disposable::Empty();}); - while(!inner); + inner = s; wake.notify_one(); + return rxcpp::Disposable::Empty();}); + wake.wait(guard, [&]{return !!inner;}); inner->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { - inner = nullptr; return rxcpp::Disposable::Empty();}); - while(!!inner); + inner = nullptr; wake.notify_one(); + return rxcpp::Disposable::Empty();}); + wake.wait(guard, [&]{return !inner;}); cout << "innerScheduler test succeeded" << endl; } -- GitLab From ba8408e3dff860ec5d7f1307950a942045218d7e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Jun 2013 23:14:00 -0700 Subject: [PATCH 046/782] fix windows issues --- Rx/CPP/src/cpprx/rx.hpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index acdf2eb..0ecbf8a 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -25,7 +25,7 @@ namespace detail { protected: Obj obj; template - friend V rxcpp::observable(const BinderBase& b); + friend V observable(const BinderBase& b); public: typedef T item_type; @@ -193,7 +193,8 @@ namespace detail { return from(Concat(Iterate(std::move(sources)))); } #else - auto concat(const Obj& source) + template + auto concat(const ConcatSource& source) -> decltype(from(Concat(Iterate(std::vector())))) { std::vector sources; sources.push_back(obj); -- GitLab From 1f5142531b273f7c598d292a134cd5ba87765875 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Jun 2013 23:14:47 -0700 Subject: [PATCH 047/782] update whole window --- Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp index f1bf7a9..4fc260d 100644 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp @@ -104,8 +104,8 @@ void CMainFrame::UserInit() label->Invalidate(); // repaint early, for fluid animation - label->UpdateWindow(); - //this->UpdateWindow(); + //label->UpdateWindow(); + this->UpdateWindow(); })); composableDisposable.Add(std::move(s)); -- GitLab From d5a9f6b5d73ec93fda338abcc30dbae73a457c0b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Jun 2013 23:23:57 -0700 Subject: [PATCH 048/782] tweak condition_variable in test --- Rx/CPP/testbench/testbench.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 718a347..b43b39e 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -376,16 +376,23 @@ void innerScheduler() { auto outer = std::make_shared(); rxcpp::Scheduler::shared inner; std::mutex lock; - std::unique_lock guard(lock); std::condition_variable wake; outer->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { + std::lock_guard guard(lock); inner = s; wake.notify_one(); return rxcpp::Disposable::Empty();}); + { + std::unique_lock guard(lock); wake.wait(guard, [&]{return !!inner;}); + } inner->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { + std::lock_guard guard(lock); inner = nullptr; wake.notify_one(); return rxcpp::Disposable::Empty();}); + { + std::unique_lock guard(lock); wake.wait(guard, [&]{return !inner;}); + } cout << "innerScheduler test succeeded" << endl; } -- GitLab From 1fa9f0d49016ce10183420edf2c000bada87a9f3 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 25 Jun 2013 23:58:45 -0700 Subject: [PATCH 049/782] fix _until operators --- Rx/CPP/src/cpprx/rx.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 0ecbf8a..a5eb824 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -240,8 +240,8 @@ namespace detail { } template auto take_until(std::shared_ptr> terminus) - -> decltype(from(TakeUntil(obj, terminus))) { - return from(TakeUntil(obj, terminus)); + -> decltype(from(TakeUntil(obj, observable(terminus)))) { + return from(TakeUntil(obj, observable(terminus))); } template auto skip(Integral n) @@ -250,8 +250,8 @@ namespace detail { } template auto skip_until(std::shared_ptr> terminus) - -> decltype(from(SkipUntil(obj, terminus))) { - return from(SkipUntil(obj, terminus)); + -> decltype(from(SkipUntil(obj, observable(terminus)))) { + return from(SkipUntil(obj, observable(terminus))); } templateclass Allocator> auto to_vector() -- GitLab From 894ecbeb0b7f758ff7a1b13e5bbefb4078f86b0b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 26 Jun 2013 21:38:20 -0700 Subject: [PATCH 050/782] accept anything that will convert to observable --- Rx/CPP/src/cpprx/rx.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index a5eb824..353d459 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -238,8 +238,8 @@ namespace detail { -> decltype(from(Take(obj, n))) { return from(Take(obj, n)); } - template - auto take_until(std::shared_ptr> terminus) + template + auto take_until(const TakeUntilTerminus& terminus) -> decltype(from(TakeUntil(obj, observable(terminus)))) { return from(TakeUntil(obj, observable(terminus))); } @@ -248,8 +248,8 @@ namespace detail { -> decltype(from(Skip(obj, n))) { return from(Skip(obj, n)); } - template - auto skip_until(std::shared_ptr> terminus) + template + auto skip_until(const SkipUntilTerminus& terminus) -> decltype(from(SkipUntil(obj, observable(terminus)))) { return from(SkipUntil(obj, observable(terminus))); } -- GitLab From caaf1156dface3a9ee47d07623ffb40de6ed50b3 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 26 Aug 2013 16:35:33 -0700 Subject: [PATCH 051/782] add missing return to maybe --- Rx/CPP/src/cpprx/rx-util.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 5d78098..92ef223 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -110,6 +110,7 @@ namespace rxcpp { namespace util { maybe& operator=(const T& other) { set(other); + return *this; } maybe& operator=(const maybe& other) { if (const T* pother = other.get()) { -- GitLab From 6463aa9070552a0871cce928aa781fb97ac707d8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 26 Aug 2013 16:43:49 -0700 Subject: [PATCH 052/782] add new Operators and Subjects ConnectableObservable AsyncSubject, ConnectableSubject ToAsync, Multicast, Publish, PublishLast, RefCount --- Rx/CPP/src/cpprx/rx-base.hpp | 69 ++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 343 ++++++++++++++++++++++++++++-- Rx/CPP/src/cpprx/rx.hpp | 52 ++++- 3 files changed, 447 insertions(+), 17 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index e50ba13..eb5cf5e 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -65,6 +65,13 @@ namespace rxcpp virtual ~GroupedObservable() {} }; + template + struct ConnectableObservable : Observable + { + virtual Disposable Connect() = 0; + virtual ~ConnectableObservable() {} + }; + struct Scheduler : public std::enable_shared_from_this { typedef std::chrono::steady_clock clock; @@ -387,6 +394,12 @@ namespace rxcpp template class BehaviorSubject; + template + class AsyncSubject; + + template + class ConnectableSubject; + template class GroupedSubject; @@ -408,6 +421,12 @@ namespace rxcpp template struct is_observable>> {static const bool value = true;}; + template + struct is_observable < std::shared_ptr < AsyncSubject> > {static const bool value = true; }; + + template + struct is_observable < std::shared_ptr < ConnectableSubject> > {static const bool value = true; }; + template struct is_observable>> {static const bool value = true;}; @@ -421,6 +440,9 @@ namespace detail { template struct observable_item>> {typedef T type;}; + template + struct observable_item < std::shared_ptr < ConnectableObservable> > {typedef T type; }; + template struct observable_item>> {typedef T type;}; } @@ -436,6 +458,9 @@ namespace detail { template struct observable_observer>> {typedef std::shared_ptr> type;}; + template + struct observable_observer < std::shared_ptr < ConnectableObservable> > {typedef std::shared_ptr < Observer < T >> type; }; + template struct observable_observer>> {typedef std::shared_ptr> type;}; @@ -454,6 +479,12 @@ namespace detail { template struct subject_item>> {typedef T type;}; + template + struct subject_item < std::shared_ptr < AsyncSubject> > {typedef T type; }; + + template + struct subject_item < std::shared_ptr < ConnectableSubject> > : subject_item {}; + template struct subject_item>> {typedef T type;}; @@ -466,6 +497,12 @@ namespace detail { template struct subject_observer>> {typedef std::shared_ptr> type;}; + template + struct subject_observer < std::shared_ptr < AsyncSubject> > {typedef std::shared_ptr < Observer < T >> type; }; + + template + struct subject_observer < std::shared_ptr < ConnectableSubject> > : subject_observer {}; + template struct subject_observable; @@ -475,21 +512,53 @@ namespace detail { template struct subject_observable>> {typedef std::shared_ptr> type;}; + template + struct subject_observable < std::shared_ptr < AsyncSubject> > {typedef std::shared_ptr < Observable < T >> type; }; + + template + struct subject_observable < std::shared_ptr < ConnectableSubject> > : subject_observable {}; + + template + std::shared_ptr> observable(const std::shared_ptr < Observable < T >> &o){ return o; } + + template + std::shared_ptr> observable(const std::shared_ptr < GroupedObservable < K, T >> &o){ return std::static_pointer_cast < Observable < T >> (o); } + + template + std::shared_ptr< Observable < T >> observable(const std::shared_ptr < ConnectableObservable < T >> &o){ + return std::static_pointer_cast < Observable < T >> (o); } + template std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} template std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + template + std::shared_ptr> observable(const std::shared_ptr < AsyncSubject < T >> &s){ return std::static_pointer_cast < Observable < T >> (s); } + + template + typename subject_observable::type observable(const std::shared_ptr < ConnectableSubject < Source, Subject >> &s){ + return std::static_pointer_cast < Observable < typename subject_item::type >> (s); } + template std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + template + std::shared_ptr> observer(const std::shared_ptr < Observer < T >> &o){ return o; } + template std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} template std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + template + std::shared_ptr> observer(const std::shared_ptr < AsyncSubject < T >> &s){ return std::static_pointer_cast < Observer < T >> (s); } + + template + void observer(const std::shared_ptr < ConnectableSubject < Source, Subject >> &s); // no observer + template std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 3bf908a..91682ba 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -358,7 +358,7 @@ namespace rxcpp std::mutex lock; T value; SubjectState::type state; - std::exception_ptr error; + util::maybe error; std::vector>> observers; void RemoveObserver(std::shared_ptr> toRemove) @@ -372,6 +372,8 @@ namespace rxcpp BehaviorSubject(); public: + typedef std::shared_ptr> shared; + explicit BehaviorSubject(T t) : value(std::move(t)), state(SubjectState::Forwarding) {} virtual ~BehaviorSubject() { @@ -396,15 +398,25 @@ namespace rxcpp } }); + SubjectState::type localState = SubjectState::Invalid; + util::maybe localValue; + util::maybe localError; { std::unique_lock guard(lock); - if (state == SubjectState::Completed) { - observer->OnCompleted(); - return Disposable::Empty(); - } else if (state == SubjectState::Error) { - observer->OnError(error); - return Disposable::Empty(); - } else { + + localState = state; + + if (state == SubjectState::Forwarding || localState == SubjectState::Completed) + { + localValue.set(value); + } + else if (localState == SubjectState::Error) + { + localError = error; + } + + if (state == SubjectState::Forwarding) + { for(auto& o : observers) { if (!o){ @@ -415,23 +427,33 @@ namespace rxcpp observers.push_back(observer); } } - if (state == SubjectState::Forwarding) { - observer->OnNext(value); + + if (localState == SubjectState::Completed) { + observer->OnNext(localValue.get()); + observer->OnCompleted(); + return Disposable::Empty(); + } + else if (localState == SubjectState::Error) { + observer->OnError(localError.get()); + return Disposable::Empty(); + } + else if (localState == SubjectState::Forwarding) { + observer->OnNext(localValue.get()); } return d; } - virtual void OnNext(T element) + virtual void OnNext(const T& element) { std::unique_lock guard(lock); auto local = observers; - value = std::move(element); + value = element; guard.unlock(); for(auto& o : local) { if (o) { - o->OnNext(value); + o->OnNext(element); } } } @@ -452,13 +474,13 @@ namespace rxcpp { std::unique_lock guard(lock); state = SubjectState::Error; - error = errorArg; + error.set(errorArg); auto local = std::move(observers); guard.unlock(); for(auto& o : local) { if (o) { - o->OnError(error); + o->OnError(errorArg); } } } @@ -470,6 +492,210 @@ namespace rxcpp return std::make_shared>(std::move(a)); } + template + class AsyncSubject : + public std::enable_shared_from_this>, + public Observable, + public Observer + { + std::mutex lock; + util::maybe value; + SubjectState::type state; + util::maybe error; + std::vector < std::shared_ptr < Observer> > observers; + + void RemoveObserver(std::shared_ptr < Observer < T >> toRemove) + { + std::unique_lock guard(lock); + auto it = std::find(begin(observers), end(observers), toRemove); + if (it != end(observers)) + *it = nullptr; + } + + public: + + typedef std::shared_ptr> shared; + + AsyncSubject() : value(), state(SubjectState::Forwarding) {} + + virtual ~AsyncSubject() { + // putting this first means that the observers + // will be destructed outside the lock + std::vector < std::shared_ptr < Observer> > empty; + + std::unique_lock guard(lock); + using std::swap; + swap(observers, empty); + } + + virtual Disposable Subscribe(std::shared_ptr < Observer < T >> observer) + { + std::weak_ptr> wptr = observer; + std::weak_ptr wself = this->shared_from_this(); + + Disposable d([wptr, wself]{ + if (auto self = wself.lock()) + { + self->RemoveObserver(wptr.lock()); + } + }); + + SubjectState::type localState = SubjectState::Invalid; + util::maybe localValue; + util::maybe localError; + { + std::unique_lock guard(lock); + + localState = state; + + if (localState == SubjectState::Completed) + { + localValue = value; + } + else if (localState == SubjectState::Error) + { + localError = error; + } + else if (state == SubjectState::Forwarding) + { + for (auto& o : observers) + { + if (!o){ + o = std::move(observer); + return d; + } + } + observers.push_back(observer); + } + } + + if (localState == SubjectState::Completed) { + if (localValue) { + observer->OnNext(*localValue.get()); + } + observer->OnCompleted(); + return Disposable::Empty(); + } + else if (localState == SubjectState::Error) { + observer->OnError(*localError.get()); + return Disposable::Empty(); + } + + return d; + } + + virtual void OnNext(const T& element) + { + std::unique_lock guard(lock); + if (state == SubjectState::Forwarding) { + value = element; + } + } + virtual void OnCompleted() + { + std::unique_lock guard(lock); + state = SubjectState::Completed; + auto local = std::move(observers); + auto localValue = value; + guard.unlock(); + for (auto& o : local) + { + if (o) { + if (localValue) { + o->OnNext(*localValue.get()); + } + o->OnCompleted(); + } + } + } + virtual void OnError(const std::exception_ptr& errorArg) + { + std::unique_lock guard(lock); + state = SubjectState::Error; + error.set(errorArg); + auto local = std::move(observers); + guard.unlock(); + for (auto& o : local) + { + if (o) { + o->OnError(errorArg); + } + } + } + }; + + template + std::shared_ptr> CreateAsyncSubject() + { + return std::make_shared>(); + } + + template + auto ToAsync(Scheduler::shared scheduler, F && f) + -> std::shared_ptr> + { + typedef decltype(f()) Value; + auto result = CreateAsyncSubject(); + scheduler->Schedule([=]() -> Disposable + { + util::maybe value; + try + { + value.set(f()); + } + catch (...) + { + result->OnError(std::current_exception()); + return Disposable::Empty(); + } + result->OnNext(value.get()); + result->OnCompleted(); + return Disposable::Empty(); + }); + return result; + } + + template + class ConnectableSubject : ConnectableObservable::type> + { + private: + ConnectableSubject(); + + Subject subject; + Source source; + util::maybe subscription; + std::mutex lock; + + public: + virtual ~ConnectableSubject() {} + + ConnectableSubject(Source source, Subject subject) : source(source), subject(subject) + { + } + + virtual Disposable Connect() + { + std::unique_lock guard(lock); + if (!subscription) + { + subscription.set(source->Subscribe(observer(subject))); + } + return Disposable([]() + { + if (subscription) + { + subscription->Dispose(); + subscription.reset(); + } + }); + } + + virtual Disposable Subscribe(std::shared_ptr < Observer < typename subject_item::type >> observer) + { + return subject->Subscribe(observer); + } + }; + template struct fix0_thunk { F f; @@ -1672,6 +1898,93 @@ namespace rxcpp }); } + + template + std::shared_ptr> Multicast(const std::shared_ptr < Observable < T >> &source, const std::shared_ptr& multicastSubject) + { + return std::static_pointer_cast>( + std::make_shared < ConnectableSubject < std::shared_ptr < Observable < T >> , std::shared_ptr >> (source, multicastSubject)); + } + + template + std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source) + { + typedef std::shared_ptr> MulticastSubject; + auto multicastSubject = std::make_shared(); + return Multicast(source, multicastSubject); + } + + template + std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source, V value) + { + typedef std::shared_ptr> MulticastSubject; + auto multicastSubject = std::make_shared(value); + return Multicast(source, multicastSubject); + } + + template + std::shared_ptr> PublishLast(const std::shared_ptr < Observable < T >> &source) + { + typedef std::shared_ptr> MulticastSubject; + auto multicastSubject = std::make_shared(); + return Multicast(source, multicastSubject); + } + + template + const std::shared_ptr> RefCount( + const std::shared_ptr>& source + ) + { + struct State + { + State() : refcount(0) {} + std::mutex lock; + size_t refcount; + Disposable subscription; + }; + auto state = std::make_shared(); + + return CreateObservable( + [=](std::shared_ptr < Observer < T >> observer) + { + auto subscription = Subscribe( + source, + // on next + [=](const T& element) + { + observer->OnNext(element); + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + + { + std::unique_lock guard(state->lock); + if (++state->refcount == 1) + { + state->subscription = source->Connect(); + } + } + + return Disposable([=](){ + subscription.Dispose(); + + std::unique_lock guard(state->lock); + if (--state->refcount == 0) + { + state->subscription.Dispose(); + } + }); + }); + } + template std::shared_ptr> Take( const std::shared_ptr>& source, diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 353d459..c97b322 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -89,11 +89,30 @@ namespace detail { } }; + template + class BinderConnectable + { + }; + + template + class BinderConnectable>> + { + public: + auto ref_count() + -> decltype(from(RefCount(obj))) { + return from(RefCount(obj)); + } + }; + template class Binder : public BinderNested< typename observable_item::type, Obj, - is_observable::type>::value> + is_observable::type>::value>, + public BinderConnectable< + typename observable_item::type, + Obj + > { typedef BinderNested< typename observable_item::type, @@ -253,6 +272,23 @@ namespace detail { -> decltype(from(SkipUntil(obj, observable(terminus)))) { return from(SkipUntil(obj, observable(terminus))); } + template + auto multicast(MulticastSubject subject) + -> decltype(from(Multicast(obj, subject))) { + return from(Multicast(obj, subject)); + } + auto publish() + -> decltype(from(Publish(obj))) { + return from(Publish(obj)); + } + auto publish(item_type value) + -> decltype(from(Publish(obj, value))) { + return from(Publish(obj, value)); + } + auto publish_last() + -> decltype(from(PublishLast(obj))) { + return from(PublishLast(obj)); + } templateclass Allocator> auto to_vector() -> decltype(from(ToStdCollection>>(obj))) { @@ -294,11 +330,19 @@ namespace detail { { return from(ObserveOnObserver(obj, std::move(scheduler))); } - auto on_dispatcher() +#if RXCPP_USE_WINRT + auto observe_on_dispatcher() + -> decltype(from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current())))) + { + return from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()))); + } +#else + auto on_dispatcher() -> decltype(from(ObserveOnDispatcher(obj))) { return from(ObserveOnDispatcher(obj)); } +#endif template void for_each(OnNext onNext) { ForEach(obj, onNext); @@ -423,6 +467,10 @@ namespace detail { Binder>> from(std::shared_ptr> obj) { return Binder>>(std::move(obj)); } + template + Binder < std::shared_ptr < ConnectableObservable> > from(std::shared_ptr < ConnectableObservable < T >> obj) { + return Binder < std::shared_ptr < ConnectableObservable> >(std::move(obj)); } + template Binder>> from(std::shared_ptr> obj) { return Binder>>(std::move(obj)); } -- GitLab From f6357ecbdfb56c07b0d77864dacb41da7f134659 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 26 Aug 2013 16:46:32 -0700 Subject: [PATCH 053/782] add some winrt operators CoreDispatcherScheduler FromEventPattern, FromAsyncPattern --- Rx/CPP/src/cpprx/rx-includes.hpp | 12 + Rx/CPP/src/cpprx/rx-windows.hpp | 2 +- Rx/CPP/src/cpprx/rx-winrt.hpp | 362 +++++++++++++++++++++++++++++++ 3 files changed, 375 insertions(+), 1 deletion(-) create mode 100644 Rx/CPP/src/cpprx/rx-winrt.hpp diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index eb57b0c..283ab98 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -53,6 +53,12 @@ #endif +#if !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) +#define RXCPP_USE_WINRT 0 +#else +#define RXCPP_USE_WINRT 1 +#endif + #if defined(RXCPP_FORCE_USE_VARIADIC_TEMPLATES) #undef RXCPP_USE_VARIADIC_TEMPLATES #define RXCPP_USE_VARIADIC_TEMPLATES RXCPP_FORCE_USE_VARIADIC_TEMPLATES @@ -68,11 +74,17 @@ #define RXCPP_USE_RTTI RXCPP_FORCE_USE_RTTI #endif +#if defined(RXCPP_FORCE_USE_WINRT) +#undef RXCPP_USE_WINRT +#define RXCPP_USE_WINRT RXCPP_FORCE_USE_WINRT +#endif + #include "rx-util.hpp" #include "rx-base.hpp" #include "rx-scheduler.hpp" #include "rx-windows.hpp" #include "rx-operators.hpp" +#include "rx-winrt.hpp" #pragma pop_macro("min") #pragma pop_macro("max") diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 4af1b81..fab0dd1 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -7,7 +7,7 @@ #define CPPRX_RX_WINDOWS_HPP #pragma once -#if defined(WINDOWS) || defined(WIN32) || defined(_WIN32) +#if defined(BUILDING_FOR_DESKTOP) && (defined(WINDOWS) || defined(WIN32) || defined(_WIN32)) #pragma comment(lib, "user32.lib") diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp new file mode 100644 index 0000000..02d15da --- /dev/null +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -0,0 +1,362 @@ +#pragma once +#include "rx-includes.hpp" + +#if !defined(CPPRX_RX_WINRT_HPP) +#define CPPRX_RX_WINRT_HPP +#pragma once + +#if RXCPP_USE_WINRT + +#define NOMINMAX +#include + +namespace rxcpp { namespace winrt { + namespace wf = Windows::Foundation; + namespace wuicore = Windows::UI::Core; + namespace wuixaml = Windows::UI::Xaml; + + template + struct EventPattern + { + EventPattern(TSender sender, TEventArgs eventargs) : + sender(sender), + eventargs(eventargs) + {} + + TSender Sender() { + return sender;}; + TEventArgs EventArgs() { + return eventargs;}; + + private: + TSender sender; + TEventArgs eventargs; + }; + + namespace detail + { + template + struct is_typed_event_handler : public std::false_type {}; + + template + struct is_typed_event_handler> : public std::true_type {}; + + template + struct get_sender; + template + struct get_sender> + { + typedef Sender type; + }; + + template + struct get_eventargs; + template + struct get_eventargs> + { + typedef EventArgs type; + }; + + template + struct get_eventpattern; + template + struct get_eventpattern> + { + typedef EventPattern type; + }; + + template + struct remove_ref { typedef T type; }; + template + struct remove_ref { typedef T type; }; + template + struct remove_ref { typedef T type; }; + template + struct remove_ref { typedef T type; }; + + template + wf::IAsyncOperation^ operation_interface(wf::IAsyncOperation^ i) { return i; } + + template + wf::IAsyncOperationWithProgress^ operation_interface(wf::IAsyncOperationWithProgress^ i) { return i; } + } + + template + auto FromEventPattern( + std::function addHandler, + std::function removeHandler) + -> typename std::enable_if < !detail::is_typed_event_handler::value, std::shared_ptr < Observable < EventPattern < Platform::Object^, EventArgs^ >> >> ::type + { + typedef EventPattern EP; + return CreateObservable( + [=](std::shared_ptr> observer) + { + auto h = ref new EventHandler( + [=](Platform::Object^ sender, EventArgs^ args) -> void + { + observer->OnNext(EP(sender, args)); + }); + + auto token = addHandler(h); + + return Disposable( + [removeHandler, token]() + { + removeHandler(token); + }); + }); + } + + template + auto FromEventPattern( + std::function addHandler, + std::function removeHandler) + -> typename std::enable_if < !detail::is_typed_event_handler::value, std::shared_ptr < Observable < EventPattern < Sender^, EventArgs^ >> >> ::type + { + typedef EventPattern EP; + return CreateObservable( + [=](std::shared_ptr> observer) + { + auto h = ref new EventHandler( + [=](Platform::Object^ sender, EventArgs^ args) -> void + { + observer->OnNext(EP(dynamic_cast(sender), args)); + }); + + auto token = addHandler(h); + + return Disposable( + [removeHandler, token]() + { + removeHandler(token); + }); + }); + } + + template + auto FromEventPattern( + std::function addHandler, + std::function removeHandler) + -> typename std::enable_if < detail::is_typed_event_handler::value, std::shared_ptr < Observable < typename detail::get_eventpattern::type> >> ::type + { + typedef typename detail::get_eventpattern::type EP; + return CreateObservable( + [=](std::shared_ptr < Observer < EP >> observer) + { + auto h = ref new SpecificTypedEventHandler( + [=](typename detail::get_sender::type sender, typename detail::get_eventargs::type args) -> void + { + observer->OnNext(EP(sender, args)); + }); + + auto token = addHandler(h); + + return Disposable( + [removeHandler, token]() + { + removeHandler(token); + }); + }); + } + + template + auto FromAsyncPattern(F&& start) + -> std::function < std::shared_ptr < Observable< decltype(start()->GetResults()) >> ()> + { + return [=]() + { + typedef decltype(start()->GetResults()) Result; + auto subject = CreateAsyncSubject(); + auto o = start(); + typedef typename detail::remove_ref< decltype(o->Completed)>::type Handler; + typedef decltype(detail::operation_interface(o)) Interface; + o->Completed = ref new Handler([=](Interface io, wf::AsyncStatus) + { + util::maybe value; + try + { + value.set(io->GetResults()); + } + catch (...) + { + subject->OnError(std::current_exception()); + return; + } + subject->OnNext(*value.get()); + subject->OnCompleted(); + }); + return observable(subject); + }; + } + + template + std::function < std::shared_ptr < Observable> (const T&...)> FromAsyncPattern(std::function start) + { + return [=](const T&... t) + { + auto subject = CreateAsyncSubject(); + auto o = start(t...); + typedef typename detail::remove_ref< decltype(o->Completed)>::type Handler; + typedef decltype(detail::operation_interface(o)) Interface; + o->Completed = ref new Handler([=](Interface io, wf::AsyncStatus) + { + util::maybe value; + try + { + value.set(io->GetResults()); + } + catch (...) + { + subject->OnError(std::current_exception()); + return; + } + subject->OnNext(*value.get()); + subject->OnCompleted(); + }); + return observable(subject); + }; + } + + std::shared_ptr < Observable < size_t> > + inline DispatcherInterval( + Scheduler::clock::duration interval) + { + return CreateObservable( + [=](std::shared_ptr < Observer < size_t >> observer) + -> Disposable + { + size_t cursor = 0; + ComposableDisposable cd; + + wf::TimeSpan timeSpan; + // convert to 100ns ticks + timeSpan.Duration = static_cast(std::chrono::duration_cast(interval).count() / 100); + + auto dispatcherTimer = ref new wuixaml::DispatcherTimer(); + dispatcherTimer->Interval = timeSpan; + + cd.Add(Subscribe(FromEventPattern, Platform::Object>( + [dispatcherTimer](wf::EventHandler^ h) { + return dispatcherTimer->Tick += h; }, + [dispatcherTimer](wf::EventRegistrationToken t) { + dispatcherTimer->Tick -= t; + }), + [observer, cursor](EventPattern) mutable { + observer->OnNext(cursor); + ++cursor; + }, + [observer]() { + observer->OnCompleted(); + }, + [observer](std::exception_ptr e) { + observer->OnError(e); + })); + + cd.Add(Disposable( + [observer, dispatcherTimer](){ + dispatcherTimer->Stop(); + observer->OnCompleted(); + })); + + dispatcherTimer->Start(); + + return cd; + }); + } + + struct CoreDispatcherScheduler : public LocalScheduler + { + private: + CoreDispatcherScheduler(const CoreDispatcherScheduler&); + + public: + CoreDispatcherScheduler(wuicore::CoreDispatcher^ dispatcher, wuicore::CoreDispatcherPriority priority = wuicore::CoreDispatcherPriority::Normal) + : dispatcher(dispatcher) + , priority(priority) + { + } + virtual ~CoreDispatcherScheduler() + { + } + + typedef std::shared_ptr shared; + + static shared Current() + { + auto window = wuixaml::Window::Current; + if (window == nullptr) + { + throw std::logic_error("No window current"); + } + return std::make_shared(window->Dispatcher); + } + + wuicore::CoreDispatcher^ Dispatcher() + { + return dispatcher; + } + + wuicore::CoreDispatcherPriority Priority() + { + return priority; + } + + using LocalScheduler::Schedule; + virtual Disposable Schedule(clock::time_point dueTime, Work work) + { + auto that = shared_from_this(); + auto dispatchAsync = [this, that, work](Scheduler::shared sched) mutable -> Disposable + { + dispatcher->RunAsync( + priority, + ref new wuicore::DispatchedHandler( + [that, this, work]() mutable + { + this->Do(work, that); + }, + Platform::CallbackContext::Any + )); + return Disposable::Empty(); + }; + + auto now = Now(); + auto interval = dueTime - now; + if (now > dueTime || interval < std::chrono::milliseconds(10)) + { + return dispatchAsync(nullptr); + } + + wf::TimeSpan timeSpan; + // convert to 100ns ticks + timeSpan.Duration = static_cast(std::chrono::duration_cast(interval).count() / 100); + + auto dispatcherTimer = ref new wuixaml::DispatcherTimer(); + // convert to 100ns ticks + dispatcherTimer->Interval = timeSpan; + + auto result = Subscribe(FromEventPattern, Platform::Object>( + [dispatcherTimer](wf::EventHandler^ h) { + return dispatcherTimer->Tick += h; }, + [dispatcherTimer](wf::EventRegistrationToken t) { + dispatcherTimer->Tick -= t; + }), + [dispatchAsync, dispatcherTimer](EventPattern) mutable { + dispatcherTimer->Stop(); + dispatchAsync(nullptr); + }); + + dispatcherTimer->Start(); + + return result; + } + + private: + wuicore::CoreDispatcher^ dispatcher; + wuicore::CoreDispatcherPriority priority; + }; + +} } + +#endif + +#endif -- GitLab From 4e9ba17516052bc8a2b142ae991d57246be66235 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 27 Aug 2013 08:12:21 -0700 Subject: [PATCH 054/782] Async/Behavior Subject fixes --- Rx/CPP/src/cpprx/rx-operators.hpp | 85 +++++++++++++++++++----------- Rx/CPP/testbench/testbench.exe | Bin 0 -> 1731584 bytes 2 files changed, 55 insertions(+), 30 deletions(-) create mode 100644 Rx/CPP/testbench/testbench.exe diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 91682ba..bbe35eb 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -356,6 +356,7 @@ namespace rxcpp public Observer { std::mutex lock; + size_t slotCount; T value; SubjectState::type state; util::maybe error; @@ -366,7 +367,10 @@ namespace rxcpp std::unique_lock guard(lock); auto it = std::find(begin(observers), end(observers), toRemove); if (it != end(observers)) + { *it = nullptr; + ++slotCount; + } } BehaviorSubject(); @@ -374,7 +378,7 @@ namespace rxcpp typedef std::shared_ptr> shared; - explicit BehaviorSubject(T t) : value(std::move(t)), state(SubjectState::Forwarding) {} + explicit BehaviorSubject(T t) : slotCount(0), value(std::move(t)), state(SubjectState::Forwarding) {} virtual ~BehaviorSubject() { // putting this first means that the observers @@ -417,28 +421,36 @@ namespace rxcpp if (state == SubjectState::Forwarding) { - for(auto& o : observers) + if (slotCount > 0) { - if (!o){ - o = std::move(observer); - return d; + for(auto& o : observers) + { + if (!o) + { + o = observer; + --slotCount; + break; + } } } - observers.push_back(observer); + else + { + observers.push_back(observer); + } } } if (localState == SubjectState::Completed) { - observer->OnNext(localValue.get()); + observer->OnNext(*localValue.get()); observer->OnCompleted(); return Disposable::Empty(); } else if (localState == SubjectState::Error) { - observer->OnError(localError.get()); + observer->OnError(*localError.get()); return Disposable::Empty(); } else if (localState == SubjectState::Forwarding) { - observer->OnNext(localValue.get()); + observer->OnNext(*localValue.get()); } return d; @@ -499,6 +511,7 @@ namespace rxcpp public Observer { std::mutex lock; + size_t slotCount; util::maybe value; SubjectState::type state; util::maybe error; @@ -509,14 +522,17 @@ namespace rxcpp std::unique_lock guard(lock); auto it = std::find(begin(observers), end(observers), toRemove); if (it != end(observers)) + { *it = nullptr; + ++slotCount; + } } public: typedef std::shared_ptr> shared; - AsyncSubject() : value(), state(SubjectState::Forwarding) {} + AsyncSubject() : slotCount(0), value(), state(SubjectState::Forwarding) {} virtual ~AsyncSubject() { // putting this first means that the observers @@ -558,14 +574,22 @@ namespace rxcpp } else if (state == SubjectState::Forwarding) { - for (auto& o : observers) + if (slotCount > 0) { - if (!o){ - o = std::move(observer); - return d; + for (auto& o : observers) + { + if (!o) + { + o = observer; + --slotCount; + break; + } } } - observers.push_back(observer); + else + { + observers.push_back(observer); + } } } @@ -656,7 +680,9 @@ namespace rxcpp } template - class ConnectableSubject : ConnectableObservable::type> + class ConnectableSubject : + public std::enable_shared_from_this>, + public ConnectableObservable::type> { private: ConnectableSubject(); @@ -680,12 +706,13 @@ namespace rxcpp { subscription.set(source->Subscribe(observer(subject))); } - return Disposable([]() + auto that = this->shared_from_this(); + return Disposable([that]() { - if (subscription) + if (that->subscription) { - subscription->Dispose(); - subscription.reset(); + that->subscription->Dispose(); + that->subscription.reset(); } }); } @@ -1909,24 +1936,21 @@ namespace rxcpp template std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source) { - typedef std::shared_ptr> MulticastSubject; - auto multicastSubject = std::make_shared(); + auto multicastSubject = std::make_shared>(); return Multicast(source, multicastSubject); } template std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source, V value) { - typedef std::shared_ptr> MulticastSubject; - auto multicastSubject = std::make_shared(value); + auto multicastSubject = std::make_shared>(value); return Multicast(source, multicastSubject); } template std::shared_ptr> PublishLast(const std::shared_ptr < Observable < T >> &source) { - typedef std::shared_ptr> MulticastSubject; - auto multicastSubject = std::make_shared(); + auto multicastSubject = std::make_shared>(); return Multicast(source, multicastSubject); } @@ -1937,7 +1961,7 @@ namespace rxcpp { struct State { - State() : refcount(0) {} + State() : refcount(0), subscription(Disposable::Empty()) {} std::mutex lock; size_t refcount; Disposable subscription; @@ -1945,9 +1969,10 @@ namespace rxcpp auto state = std::make_shared(); return CreateObservable( - [=](std::shared_ptr < Observer < T >> observer) + [=](std::shared_ptr < Observer < T >> observer) -> Disposable { - auto subscription = Subscribe( + auto subscription = std::make_shared(Disposable::Empty()); + *subscription.get() = Subscribe( source, // on next [=](const T& element) @@ -1974,7 +1999,7 @@ namespace rxcpp } return Disposable([=](){ - subscription.Dispose(); + subscription->Dispose(); std::unique_lock guard(state->lock); if (--state->refcount == 0) diff --git a/Rx/CPP/testbench/testbench.exe b/Rx/CPP/testbench/testbench.exe new file mode 100644 index 0000000000000000000000000000000000000000..ce8ef7ef51e160e1da5e1bd243ca203859ba278f GIT binary patch literal 1731584 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

gm|)NzeYZ%k;~0B=&%8Jl3T87MbG^<0 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

=gS+)mM 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�n1PxA@t`^GNYFa#?sG31K;ssz2TH`dLwQ;+ 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℘Fb>lckCoIiNWVXO=9nfESzi zK~n@gpj#LBaxgF)b7p3JEuT?>P%sgpU=Bn9oAH5{?i`>6qu096AABj%edyo|4&&RM zwa@koJPKoIexH!mS^Da@>k81es$Le4C&bDeUI^PujB&9Yq#sG&e|o7&p{_|8M-b}1<{J7OFCUQFdy%%UEs&R{YSU! zhBWJA-K7UQV_Q07KY%9jVt;hjZsBi^U}9j{3DS{f>ARrYcLskms4h;kuARW&4!YPq z&AN6?IY(#giFaWSgem1vl^dte9heL z+tKOtr}bnBbJ~BVZm|At-vgkn$S;{7#`$&n9%%hmzp2}IMtA9kZm`|WhnO7v;Ld3M z#@`RxdDmULrQ7vK<8h_~ptHa}bh;i$YyDqm-Fl$HsN3~R_qFa52VcoE9{`<4c8K{K z_~P9I%m+G4KX4xeufApe+39+q)AdJM>;L*wAfgbw+>se1P?_2td!YOH_Z!BS__rTm z{?X~Wp|f_2Q+I7kOX!CZMt9I;Kn>!)tt1K<)R&H6_%NarW++9heAdxt=Kejjz0KIrs))*bpJ zt+V#kYenM&X_l@__@^B3Pz5dYV`XUgUk}p8cS7tbDvP_J{KMPS+OZgZ$fnfL+^JyCu!~1b?#w6X*iVmNaYEIsDDWpri^; z=b8`}G@ToPc&#V#r*lEDq64Lp?%!Q+z*0F+bL|y|QnqH$2+-E<%e}r|vRFGqH$-%Q zXgyFD(OdhV*Y!rPO?ap4gwEPE{M!Zix3lxFztHXYr!#g=uZ@89k0KW9U&Y`BZp_`T zb2=;kv>pJZX~yo_HQlZgnvXLzzhLUDUE|m3I-&Jj{od}-4c)FQnh!ELd31(u=yYAt zdZ2zXC;^v36L4DVe}2d%JfJ*3qxD;b4k!^{#z@4>x525jGxh`bN9G@$rJ&SWf1xvW zMtA6pEQV-M7Kl#k_Wb}ZlhUkDlna46?~DwMzd*@~zZJA|9g?*8Ti1dbQn2L3-#V3n zfdQ1nz_|mQ#159$fX#6Sr>~ms&<|kCAz5T5D1Sh6$BNF{E#0*p-&{X1f^tXfm+oWT zrw=}m2jz*^7hiGT;J$eA-GAQ|px6)nPALg>IDvlxCljPZy$6w~J4-<+y1VoNI8jT36ZIafiTazX1Y@^v zPq*ui?pl$wPR0_m8O%RAYj?E%uh$2akBne%r&+o-AgW47CgTGR9gfV$99axHB3WOq z0qt+9-H|04Vf~|yxf5j6i-Ye48sGo3XJ9Zskj2qiJ14Ev^;LK5i}>zS-Nz2TkY~Ph z@TENSZRT&>H@Po>GFI#h|I)|ZwR1XS_dqgP7DIIF|4Q@k_Zy#sc0bnXcE|4NK6UY3 z_u+#NK-v?@w_Le^AKGj=$z-Z{hVJ9s9}m8e?>@!+ zAM8@@3(ViTU5{{o?B%iO^xa{7zKF&8M6qqAAX%|956L8tSzp6tHR?YpCd z(XHF{1Sos_Dq^wzQOxMZTzaPaV0Y+_?(@u-4!)4@3_Z{p`k+_Dp8LYVm-4+VW}Tr= zxDR&wuIO}qaqxu%i$O>1>kdZ8Zr3#)ogl$Atq1D3yIo&&y6$;t2RcT+w5PjvPM72V z=9f%1rZujwIU6i3OF51)8hBctFaB(OzL>=^?LXT;#%|XhtrHC|nL9j~`S+ddh+$+g zKHvZvKLxKdcUuJ>tUBCaX;8`v()rE$eDRrX-yVW7&u;LN>EHkV#ry(D%L)My#k4{JL@};lDq(9p$-uzD5FEz8{ljhs&@GPF zAih(+T%y+a3*@a5iN;?H91IL4Jl2;>g&I$SJn))}`}}K=UeNxyXCRRh9_#O=d?3>p z8Nf0OOrQh3cY$`mwjP4m!@>ZX*#F+`%JKc0@<-+4+#jqz^0$DFj|qEW&je}-9*FF8 z{c$t*$LyQ6KR}nIeS`QS4(y9_5MP{w_~IPI7v~_pI0y0t|Mm;rr<6~ZXf^%>J6xvm zC)DAmOT`+`ft>l8ukjox@?Ntwo&!Zq<0Fu0i9q8okZ37LmI3U6bD;f^2-lxuU|?Z@ zoxt1E3G()Hd1ek~{&lfmxzF~O>olGO1rpeGj0_B5 zj}YgNgWTtgkFAtv=3syX9zz4@px$oShA~jT-j~Dp04S?6I)Jh#bMpxnQ2u0YKEVOX zoy^TA1il?)EMaawp#aU4%*`j5!n!Z+10@4!%D+~k-1rL|MUV`74U|E7AQ_Z{fdQ03 zSr{0)FE&16U|?n_;c5H@S};}0#(n%X6Zf(BIFQLK4A24qoH4VwKpP@BUOYMn+Izzj zdl>7EF3?`9Hww^1mew82Q{%zE{ZJZz-hog21qT??_zNyDbRSgx&(FYM`+=W ze?DUx|NE0^{G}(-_)8C^@xMNi#((`_>w!{}=7R#SFQ!=^D&cNE$OPJq*m|J!1E|gv zGpwsma^NH8jjSswL>IQ8-gKWDB4g;N1 z4LUTpJ4Qw1J8196|B^uMQ{NAPHtm;4@NZ+`vSKRrXg$F1a>J?lHDj5{w?oXOFM3(H zAnyGGa_`M<7A|Y1(o4;+S;|CuH~jzi?_cvF7SQU>l?@FI4J8+i55z?u?oCl)kUr3S zf-w$!9TarOW>~35Gw42Y@fS~yg7&3=_h&wP`WL!C(++$>(c^uf7NBLRK$*yky$EId zpZ@*deeAVVTN0ME5N|tG8?qv7<3lD2xwU~ z7vJCi-L)KGvq5Lsf=}frVej@8us&BN^dbadQP|VJ|6ludyMAci0orQGP|6<|9R4Dn z7ks=}_lMU;+Q0d?vB>xOeh3VB!F%oR|6bn@-5>b3F$V^`_;(e&l-T*duRsatNGTTU z4<(mCdn5lafb9AKI-&w}>{K*p$rgNqTLL^>!(sd_i!m%L9K0C##ZR$+|GQ6hy1r08 z*y#)2nf~K{Nn{pNSXlUryCAs}%|`^34}o^LId_-xbh`>@e*`a@;O{uez`#(?0ouq6 zI>#Xcl+Cj^{)>hj3gVospN||(3(9^g~9M5_{iV?-3*Z7;KLc9nkoE+ zJ?P+0P(R4^Ph{(X8o_#w#(yBwir9C6sMk#0$3WYE!(Ys21`iy793wgtw0`3c*eMmt z^(R0V@w`6t;=tj*|C=pXOSxaXIt+?=&=CO5r~h-t{`g<|A^ZhoW$XXaFIfz5hXx!7 zW_X>}dZ0e9hNbmeaRw~L!(ZGLMc%&c`2YX^@E7H(|Nln@{1-iP5V8UD`wfqo-8Z@q zb%QQGR|ai(D^+`u2eyFWlyJ$AAw$Np&k{hz<(D`+!119&6~s%vt!i9aIH1M><_Ox?Idvm=5soyU^{*bMY5syMLrDC?ZNcA-n#y zAlvE14C~Us44>&f{-;wVJ~?8fkw>yc)EXl zJJ?hz`9kCnC{{T^gRFi$3g8~dOVG(~pmQ~NUwk_Vk_Bxqc>N&Q_%^8Y7VeB=0hRIf z-EJJs5C3(tb^7siyYVzXc;6Yv(tLuc(~V~(XcV_p>xHcE-~Y`A6s$j#@VpQNvmLBI zlyZl^n4|*PZOR_@qDJ)J|H$udJfPvY~5}Wpst=9OY6xx z@xY+)7Yq#G^xA#nwR`hPg-$=7*QL$>|CdNN|NmDa)_uJDJZR7TL-~Ub*_e62JLzAu z?gVWp{pQG`P$H7W6dWA>B1Q<22uqB*-8i~^LC2rIR_b=;Nb7X{)9d;tizy)dxGN86 zPT)l^Xw|weNAnS$?i<#zJSE)CuyA_K%)k9$G<>%QXg_9_0cbZNe^Wc?Sl;FzR>kc6 z+Ye|Tj6J+d;6G>p@DP7<93un6t^_s+uL;EK_2NpiJ_u2IDE9EK4=_nbMg|6mWYObY zX`E0k+6d9Jy@6$E)`$3;#1UdUVPeb(v86CE&^#H`#ECGm+n{+uuoL*3D*ylgzblOg zY7=N32Shc0Q~dw`|6w{nBb6|5cO>zNNG9onObXxwn^aT{Q!NQsU6c+JV+9@Jb|?U} z(>=KPU_hGnLH?$X|Nj5q_x)hp?8kvCm-(0sC?$HV^MhlnzT82 zIE`P(MTI4eU*tdEz@U9WcY+NA z1NQ|`wY5W=!4ZsQ_AEfbXoJix3Jdnm8@#YhMX&Tef{x(jqo zM)MmPu#W^fLsWRWuQVS5F*qO;OQ(p+3((FXaD)pq9|7Iu3RVsGzbym9hx%ee(4{Bf zQ&ozE)A)s06DEc*fI=T)(HxLa222QK>FZ9AgTQ*r<(hvnluAMk_)uTUewQ_1VhF?G zyQ~o)YS$}f28NemppLkU3ivXbdRqpD2@b`rU`Mfh;*Vf8m>9y){6+xPWxbvZ$65>i z|NsAw>uss^&677jzUGAr7`?su>fXs0paSFOi+cyZwI=@m|DUmh<>rffAHN-PC}q0& zm+Nf_)6EAjoxc40|H6%tfr0x#iHOnL<{wNYOy92FJbCls>-8@!zWn?D^4yny|L@+o zd*ill!^9A%jZBAczP)+!=9AfX_a^-R|9>{b0>{!zH$NVRIDrYIp$p_cu9Ky~hi|@l z%>>fIb+UBb&5ws)-uwLT|BLes3=ANXxlWey-FyeyfW`)K70e8Xl^}_?TyINW-hA-- z>D?PI=Y9q`2<*5BbSE&D@`Ee}xfI1HmY3;ZT`)~eC zVYqh_-Dgv89=Q1jVO!T!P>9|IpA3#R@xp8y${Ri_(rEVU$!@Fr>2m?sx zJ+N2_FXSp3(0Nr1uYc?SRWq+YhBdz_>HZSd{D$MMj0%LDeYcF`MF1P9{VH-djpHs` z^O2Ic)&nK1FM~h-`;REaKr>%Q4F3NAA3Xc!-WX6!Ku>lk5qWX_Cl5nRK-LW1 z%e)pese6P2vLxxndI#O(VIK#UUp<6s4# z^7~~k0|Ud&wIDUK52tmvn*II%KTY*ReH!IYEOWo&nN8774= zgoSs{&H4ZTzjNnY(4qO?T0ud|SSt0Wx0IuIFDOcuE^VmhVJzY3EfwgkZCbkYZfsXC z*h9T@LH-C1fEdu_%*Vg)K){Q{-QXT=eB52vu9t%U|AVeMYlNf(XmrSd8g@rGU=aX~ z#OU|`{=aDY_y2!1_?DjLBVU5kx?TCwx^I93$o4~hsa#s)>Hqap+Qe^D)Ne6yhA<5qlY7z0bfKJrTVv5o}#1B4})q}qUG@aZ0 zf|b8zJp%)S2Y(CboLw*Vw_1Shywd?P=o16j#S=j6XAm~B-|x!3 zyoL~cc?8V90V>g6UIVRAa22@u;;zI?h)$RIs#&YZvQ>*dgls= z4Z8jJxa*w_@NmA%aL4z@T`@#t-Hm@GIJqThDe-Ol=@F0jm^Fa`U(Sslc zy9YrGhwcY4cs&SWSa3gxVaoj=hOh@g43!Up7@8ggF?2r&0&O@647}^g5g2$^M&-qh zhoG^+6%$Im;6jy*3=DT&Iqp8Z{~$8*?#*vUT&lG1@JRWgc*Ok`EUmV!-xNtz9OYomZbuvH8)?} zxOo4;wXY7;XxR~OVFu0AaRhjj@_;j{H-@Zp1yJO-OCFM3=Ed8BBf3s z?Y0Q*+#u~Y-@OFQh26UeG7_Y*lpAUy=x~+0tQ-%*7>vK&m2i6rI`Z%C4NG61QeDeZ z4#-~FoA2(r3V^KrcEpjt1$27K4X{D1-L4YV(RXj$eDONe(v_z)*0PkNG~%wS03_@- z{rmqPtTi(7#>MUvV5>`oLC%5L-TafWRO;q~*J4o9szg8{93amsJP2dxc9pm*@tU*S zR{~_iT}jZDs-TrI;MlqO=WgteyRJV#A$jJ%YRQ3MhX1Nh4g@p6x)j}@du@4t{rMkx zxI09Jqt}V2+v|hzi5FTE|Nh?*aVwPJrN>mz=+lvxOzz+R_xf&l$#w4A|6bocFO3?$ z|A%W?V|?Pp_X&Uh?=S&r5d~}Ec&YD!q~wk9i5FKuN(4YkK27=izuWi2%Q?)jKJfCQ3&_6{UY-Q=r@Rb24@x)-UV4IP@G)O6?am|Ot1IIF|Nq7( zUTo<5`+r9Z$l!C6K%U<6vIA;>07#?noR=J6ddW)$FumsG59Dy0V|?O8F35-kkP+P= zBYHzX?Jy^hDZM@*ra71iYNfo?0W(3>(Mv^;dwV@V3dF#ofByad|8h1c%6mCLq7%SO z5fHN#%v1m|tH8_>5HlalOaU>kfYNpE8;}VnL5Z{X42bCmR&WEvbOtk@fS49wCTLI4 zOIk?*S0=^;x7KT>_e< zJnrpVCD-D zQxDAi0%9tInG7J?B*0A2 zQy_1i05M;KnO8u}2d6+5CxA?F1zQX{_Vnc`u!0#N1^dCwB_QS&FmnTlxf0CW17gkt zGeKegax$1%0ut>2GaEq6T96gc!nLd7FSr1E-}(3djtii;;qCkTzqdC7lvG3Jh>Mya#52ORUQ$k;(;7xnz9eg=;6Q*0Kht z!1%-q36PQwkPv3i7o4rX*@Ds` zXw~A&*R}`^U7#2+KJh}g0~RjIAl(~4x*b8feHXm^4btj6;pJx#-3u;FUVx17?RfbB zB;-5ex}V<7yH^^PS^rc{O4*Y!^=xx#d}`LfXzMf zQUuxDBgQ9Qbb^%L04ZJG^%v3TyJLLfMIK0M3rMO5YzogyHycoZOn7Mrrq{fjb_5gw zpn<@b-5{p#ftQDiK}iCfIxOCU{B+~xhGK;GyP)AM1a~V3$d(BpThzd|aJ(!q2Q_#; zG#})6Iduy{s~0F4-fI2(e@6~T^^ZW=| z%mr!o0BPP0*8JdQsWp=MpypT=NQnwa$qcX(o|i#jb0@s?0@G_=E;N4UI$_<0XfI}he(Ik-baK(;V|Y%zk`^2X}>|8Cb40WVIz1@$3%eGk06X$A7o zj+cfYTObKu?eMq%-H^7|YI9IHgVVkMSQHenFQg(uI;B(SwxUPgiGB`-ID%;^Qk@p2H;_rS~hg&@1ZSuo@+#FjIK zh=A+@#lG>07kY48R6w@u0NLUMwdIc`$a6vOq!D_68P&)4;auc=--wBqRtQAA|>Ch8f5k;2=B; z76k`k5Lgr(gxf*dd~dvbUx4H}Xb=X%UE&UMNdd?usZf{5!(8&`HOwVEP?w~DjD)x( z5^N{9A$`vj?hF@s?J|LIe24yeb4=$kVLl!?8+N2S&&@`O>}9EumFw$8My~!B&eL| z_2qeK0yc8ROC2yh<7LZ!kgHC->?g zJ~L?PlKm2vAgjTq?|69`kaIxVd~dwG zl8Y3p(5zwB01Gc2kV^tUF7bl8gavHviOz&8A}a-%ss&P70aEG#R?6{`$rMz(?P)&9^76Y0 zl*#i_#t_O>c`0ZJN-8&Aa)RjtFBw5nu=oWv1+LY>!uL$w-~T&8K&HQH0)>Rg%PC+@ zJTK>fjD~5tVtnGoLXc7ekkb87rI}Erh3HDlKuUQ)N~eI8^1So|r{)bWmw}QV%v6w5 zyg^D|TnuG+nF&_<BG}`IzVBCQzdEJ@E1sa^n_M@2>|bjQ}Y<3(CO0A6~X2 zCpu7R*aK2x0#dRHYFY}i5>NzYf|Lk=l(d7DJb3AduEY(b2R*$KX_X;H7jnQmzL@=Ywj{cosy796h z1L1X8+woBqEYIJl0(FZ)c7Lk_g~N-N6Ocm{R6cD5DOm$jav7|I=Vh+}s7zV#@+sIY zCtl`)Z1r97@+z2r;AJeBKjmd9$YHSj1{wm)0vXi-GO7b=loQmbSzxUvUMhjLu6Wr6 z<{x+|1m;h9sfBKoJjkdNkWsc!qrU4yT;&hedgA4E9T0!TOM5W?z{}%c{*;&Zw;?)g zULaRpsr>tYhXcr{Pqm;h;CZ%d07cE4bn<~w-p}# z$zV}%_}|zH34exk%s-DOa_4ZwCTc-aB+vG0kO0w5!OSG=qM^AEga z0Q0B3lmIydIdFMFM*TP&%J5PfYSdFbPzX$Tc^6Etd1;F91}Hp1-GZbvcrv>F5aM9} zG)xC?tbjRqdBxxVJFb9iIa&h=ta`BNJ6@K9=?yQ>Zv!P((1MbeN5D+*IOR?d)Azv3 zkEtLF!Q-ymwt&J7+_l!$28n{lT^E2w!Oa3uu;?1lP|>c<5XWswMRME*$Uv$H+;LnW z$87*PP6O(s6hKORptiArZ9DNY4w}-Yr6BqB0%-oD3>Ir2%l`h~ z@#jn^!%Kds=9A!LH0R|(Fn#8wB*+j*62G?@Qp8Nt1VswCh~WkaLB>@Yz@p$J{&f>1 zQe=@Vh7~dOaJx%EcHaQmJ-G@LOfO#Q>LEE4RKx^F{5XfQ3k-`o#Y68e8Rj5(-L8-`h!Aoih4XlhhRM)C+K#5+r2AzlyC z>;cj|7pgfNta-u9^<vo_J{vws*zL`C$Hmm+D~tl$ZAC?l1uvr2;Z42x=4$)Tk7& z))Oz^sDnad#mf*d|G>*TVE&YsUpAt7>1D~^|2r5!MzKSUItWgZ3tmcswVrsn5Uh2@ zOHMHVz{`nX{*;$1(T$o1GV0FhP==R#Dj=a#1~uv&$OFD7UWS3Su6Vf*%s=qb4a}eN zG7jCSV31KeKt>fpjnW1iHRq)=m_GBe8kEu?snY?Z+jq*#A8PQ_nY#g0kbo<|M_^HK z>I~liNuBkHh)9B^&WFXYc)DH;>iL80{#p+5#*3Hz+6eXFB4Z0kNdZX7C9o2nmp$Or zxZvdzuv<>N%mLZzyW-^)F#o{I7%+dz%My^okW*(S$S5C>QSDHp9KlA-cxefy&%B(t z5mb7DyG>yr-M&*^@_|f)bfBF;Kjo$GdbDKf1Ttz5$fyLU zQBqK&iojY=y!@pCN%2Ww{(+aT!2BsMnb3{;UikO_ju{}MM4?8V2PeZhFOP%iGcV;q zUW25qC+i?3-yD!>kjh;UBm^n>+Q6dVwDo%}B*c~DkwP5Qt2I9HqO}kf;?*F#OF(wd zECmJUiJer0PL&spZa4!qo}3<|s%FTbt<@prsj3*tjkRS`%D z)YPsDND|so0O}!w48BwX@&?b#9b;`7d?BqTtyqqcxC#Jr#=xs4h^u!1%-qodQ_EDuG<|b3g_kDTahb9oWDfFU!F6l9%T|i32iaeHg^_J@E2(3_LU% zK-NG)!xU^2I5e`rqTtYw2aAG3LuEB2H1@-)Q&Z8Qnln11ACRpi%myf{~A9&e~taOL*i5CHR zAm4z>AUBYv7bigdU#O;aP)%Xznxx^H1VNgPfHdiYH9dK$37UC@c@5<5ce$Y90FV+M zu#yKa!=UE=Lke9lkYf(#!W^>`q^Sm^>3Sh3JUCuXR0a*Ld;kr&w1Jo~D?S*Xc+m|~ z9RX6k60BO}Wv~J$;CWs~BP#{DCIO_>1f;YMtaQ&y3s5HT-SScZoQkHr^tg&tD1uhA z=z_EefV6mnwcL66R0WYNyg*A+xIjwY91mr9sR34U;iVF?-)H z)g%g<*oOreC={YVN@74tD!@t}ygVci3a|q&vyjaN#fd)LTvd=J3y>yfsHR@1CR21x zzp`OI_>leg{|*t5CO)vHCodzwnvT3=K-L8E_EET|-5^aLj)gM3yqOR3_JfzoU`+>J zo{mBaE0FUhz%{jjG@SuyS_0MdP7dOyY3Q1w;hF+LnpS``<%2andASp;>B!4OWKAIF zslheLfHbv$G+9A4nb;sX3lzXVv;O|ykpNO64pou}HJ20J+;ds5usQn)bZB5{YE~2ICViX2Lb~gEUEiG_3_|y7Kb7EXdniUd~6>w7~epixjw~D3GQv zM?)E2R)94{Y#!pr3#b0M<~Zz4d&HE1sOYagoSMe$l4T;wQXQ)AG{O*YXvu6 zOTpHHXToMJ1vP0wQwA^jWk8MrcZglUqF{IZlm>}{*Av(+0jUMI1RqNySHu7-nRwC80nH~_$H z)FeAIIH(p)<+2_0A<&RJ# zzb-L8@nSDr(`Jw+7m%ilpe*M5;bpfBv=-!e`2gf}-w(|P1zwhdM4|2lk6BcKG%A2J z&d36V?17g?a!9s-Rt$uLl>9jy%J8xjtmMMWd}N1!sw@+bk{ci;L0~03FL^-e%J;xa z7i6WNVO>s;(k&pR>QJQ*!C`XXr6ju2d#Qi_@0b8m`X>|QHlCN;pi19`Ah{7_>SmDA z9FWqBP^H~arH9d#c7T+6fRrwSDoubYoq?`27Nk@Kq_i5U)D)^T7hS0lNGStIX#iO1 zm6u##rCVM;0*Azdmt7K|tU2SQQ3!}$@p2Vtu^=oeI*d=ec%K4G0#8#wlk|r|8D27j z4SVo%E^@qqhQ1Ghl7AGUU?-h;S-udd z0R!qP=75wIfRuJYm8w9M`k*Uy1S$0aDUAm!<#{OybwD7x1H?c|H9$&Dpi19Kg2Ldy zOEq+*uap1&-@yV>$_ZBb;N@XSB=3NHegdTA!NE|5m(S86K3@Pe?M4uiQc$Xx3sSlV zq;xk_X(?3cT6CpFAf+=vN+&>-dO?*op(}Lx z{sG7SmX}w+f%M>IjTk5dX1r7h0?{j8&Ou(70!j@JlVGXgdeYzjJ9I#XeN6*-_`%D5 zq{7k*6ee3hN;p7DE`gQYd6@&Y=fuk?^U@KpnFaFU3S5uCD|054>ap^QXL&LpBODfG-R(Y7WRKL#R=&#X(vZ zymSU@J@N9i2#CMpr7@U);N@;Gf6B|t^N>6MGU`O)-~T%*Kt?@Fg$$B>2t) zE8i0@6~Ing@v;NVKk!lj%%Ad71Kp{zAftFdMp;9R`U;Nr1uuQUT2H*ZDh%GU^D(sHIS&;-N-u2Wvg?(jKgJ#mnVj{(+bJVE&Ys?&wC@fQ(uIGAase6vxXF zaio9+O$SSYl+=Kfn1hu(dD#dy?Z`__C$CM=`|96}L zDgB-Z34x7Jr7wNZLSP+8=?ak2Gf<^%P^J6Ol{SNvwt$o_ger}ODxHk3Gy(wO4opt&W9?Egeskgt~3m!v;(BH1gcaI zsx%EvkaRB1oD(h!i+4IrgOP^CIh zr77r2H9<;yKuX=AN*SR_Ezy1B{o7m(7AagY#L4ORNs z6Dfv&U`r1a0OP==SYp-MxcN_)|j27#2`04XhiD%FB2O+r_y z4pO=Wq|_Cv^glnuTjuCW|3rdX_#mZHP^DL(N_o(gUIZ!40V#bS3kiXhP^Ax%cgulF z!et<(9w4Phpi1kYO1Ggatp+Jo0V$mcR(j{9F*vqPyo{cPR0D%r2mv6a3?QX>P^BDD zr3UCqRY6Mc>O+|CSd63d6Af<0( zAR(}v4-~E&UjCm3YSkQgX%5=ST75<2t4TU zi3@H$J6IHK{T;9<*!quCAl6r6vHo^A%=(MrfB*0B0a^b(8svM9mz>C932HU011Zq} zDLDgH!t=6?7ZgATUhYHQvIt5d%^;;LAf*eTN~57lC!;Hk04aU2Bb4D~8C0nORA~mf zQeBYJJs_ptP^GL;rMBownLtWsfRrjgmEPikxK#*U>Gd$s@=lP_uTdbM^SoRSRr(w$ z#JoV>S_4uV08)AisOqyJp)1t} zDSfg%l;Nc(SSiQLqm6T1SYp9i8p0-OF$kp2_JVGJ*qqwCK= z(=P$j?|bLvoXJSu0F8P&g3J+_7{>529%K&4{vU^s)PNGCEJ#huq%ek;)*v-7zk+Cx z`V~je)V~b@_4`5Uxv{DL0b2JD8!-TxzZaz5W=0sp%i9r1VF5E=f(@x^0IBZ8^%f4GRmO<;deI7vFW);adAN}528EX($gBWRyy=6? z0{Q=kJ*xf{NczukBIyUMXT2Bq{`WsPzBRa!)PVfA7Nq6^Zy3YN(;zjV zaDZX3edys=3sS#CC5++aY;^U#z87A;=m!-{D_$Phg%nSqE~slTtW>fFnNYzP#_%!{ z)dY}z5-|Tk)8mO2X!yY55VSq)XAr1k*BQp}QXJU?kp3HXsNvIrP5(}i{yWBD3@<_D z1kAhO@QGOS2eH8i6h6HmwJShsSBGIqFEc>PZD4K#<+WIl`W@3j@sCaY3FJ5enXd~{ z|A8-z;iWe=^*hkj{|yAK^!gvl@KPFGeXs9?mlaM(@!Mm3;>B5z`T+hghL^8H(cItb z+w#%_S$%`?i5GK0>d&x;F}&Q3ss6#sA1t5}cgD*F4j_8PO9}7_hBYrIAP=^I#$rMP zLGcapp*P4xla4Tkmzk(0_WC|}xdLil0MtAWaN)n^%Zq7VJlwocuz6l#3@?ij=JCALKrUZEv#Yuwbw_GI z@efl6OOT+w6CI2QOTdHAfBiu)K~PNnV$<%f5j?{;bk{A^%g8h?gzQY7NmZUNEpM*Xl&{uy3x$%1*zXq z6vpsU8=HC#boF=rK>N=@<)w$=78c)1FZhS%LY4;IcHvSfOcm39(b7m+N|k2wQfLv=1zJ}MI{(5Klx{&y%(uRv?f}UB+%S6)@vHE1 z2Q$dt8!tC7BgF$~`e7?bpAAPC!^_Ko&~WPYm3Y|!R?qV?0lY^0#>)zHeYGHc4V<9z zAEpms-;0+X$m&7i;tNuL0Ax=#rh18&63FU7Wjp9_%pDmZ_12i`@4S4$gyav<;()h4 zfB*0B;0j}S$&IPr;pK||p!!JT>6W|#GeO;qm-oR;@JggBpfuDQ0$Naf5-genV*2%fCN32~ zOlL3?yffbd%ya>X>Vlcz*9c&nQS9}eaX#)~11e@yvVt(renG4>T{~F8$ zZ{2?YW|n{yTm>^*K+IEM<^&LPKbQ$VS7Hm82|ib1C7205NnjqB2|ib1GMEWoP2GW% zzq?c*E2DpTfewEW2xE9D;SY@(aFBQVK6$CpiBx`ohWXEe6pJhXm4AN7iqD)m15!VO z0WCev1*vbC3o8GxsgL-JWIibU<$~1ffZCtknCf4={Gp3vJ}AA|g490&wGX1Psn6&@ zG9RR#7o>g+=YaYG!C2)*LGnjH z^2RWEQ28YB86Z70CI>d2ARM!HH_iqK_76)!NQ{pG&65};zbikK@BL#7JwC?%O`>4w}67I0W9C^ zyW?fYCnR@*#@=l`U?sOPNO_Ay7{kjzu<|p#zBgXZ_zCjgftM40BJ{ylEHc5h{&4^M zf5#f9Fou_65Ut?!57M83ycrA>k7wOs_8kUkx&cbr552+u>-Bx|az`t|9xqUOn+sCq z12TFyL>1U*Fac_>bs(z;<*!_j`Y)=W`X56*`{nvi27bs^`KFzRUq{eDPasRPhhH#MO6oD9e1yZjAN*ESs>R$xBIE$(Nl`Ckt-z1FTB?qSZxtQvAfz_LbF}%Fti5fmH z0$$`|s_z1+zhf50@NxyFdRt8OQ6Tj)_F)V!D^S$;`f|L~0O#K$FHbQb9i#v{m_Ze! zDc~z;{12uHw38>I8B|~2c^LrOzvX-7r3Z))%eA1$cjXW2HVe)!u9Ic{K0)3^VJL7l3_O(07?G(X^gtNGpw zS?bea2-7bBmwVp}S$35JlIw-6(FL`?x_#%oj4%W(Nty660AwW8->~KWpPWHm0r4<~ zmjYn-g8ZuiZnsIiRA_?uR|2FD%*Ye|7x(f5(SuApc{PzY3Dq0Ga>U73zP` zNqQW}JI6pPmDYmP-O&d1e_-km`De?^8^{Z#K}$kwLF!L@1I>S6sz3A6<2zFM4XS^9 zLFzw%`U}~Z>KDBH0bbL+<)r{fpYN5I9N$6dcFju$5FeJ_Rv4dn!3r|x2*?~|m^t09 z90A}n1s4}V>vxz2P(^md0W?eiYJhxlfdl}k{cz(G$b62M7eMv0?}L{oKr~DnXv}Rc zNZSHXeX|>?4Hg_{K>fKHHAwygjc(+E)NcTVUpF@OH>%Op+k(_jZ~^syG1YUt%&0?B z59&Yhg4Emafcn3f>Umz?_==<+l&|jE|NXzi1r$!dogv;va{r!}7RW16LGig3q@D#- zf1k!wf8}KbviYF!sRgNj0vb=6jj4XdOOLOh@ZIpz0Zi|B*#X}7x#y(-cpK#cX#7q< ziQg{JQbOYsFO=+IO%(}{B@+b07+#toSptshv&%vCC8()$_Y0cWAK8Hxf`Yoj3}9WL z@yH#>ia`C|y&y$0p#I`*C$#VZo1Y6dAKsn-Y3TxK;Q%H16)0Ljj)*`u9~AzvAjJZp z&Pg?jVo>?xyXK_?s4?Wb;ibSwP&nOqxdVAy7U;A9Svy!D2!l-m#k?WJq+Z_@FJFMe z@ybgFkUrNB&B*mrH>iHC`Su?%_zzmle8v_OD&IpHUcPcf^)Sf&8sPJX*1Wu+fYeU` zjn_`Kg}I{}WPlB*BwLAU0H{6qrw3`g6ckvoAk|AmLF1pOszLp&4=*)9?K{xAN{*Mc zpsWF63cM5oiNbOrC|8MtOu6D3#_-Y!q=vIx}tP^kH~2=j#y=5GfLOoGgp zd3gq8KC+>SAVYIx!WdrGJN*5B2GriMKrUZE#gZ*Z%@WXfdo)N5#AXQD>nre*16n>Y zfb@Z^VR?D<9oQQ$_kxNZkPy$yM`~(zG(PSD zT8;$L$?|e8y3R!)ogp4!3@;CWb%NAeAk^ogt1kknf1ne_@NxoNy#_+PExLLqkops~ zVGJ)5;OZq1>Uq)C3xU)JxQ8*kG=Qt;K&Zcq9{i82{{G+5P!`7Uk^!#%#~g6rffC7D zboHA+>U%1~7+zkm1BDdGzb_E#Ythv=fz-R`hcUcd09Stlq23o=eGo`}M@1OJ%L2Ii z6A1OP=<1a~>ZeqPF}!qutKWf8{}z-kkz@LkC1~ic3e^6Ct6zaozZYHoA&~l-(lCaX z4{Txnoq`hWNPP@w2zvuueFs8)EV}w6kop;*q3i~@`U-@4U3B$EAoUTRVGJ(= z;Oa9F>i>e$J+gn9KfkHF9NAI z@dc%SxOxkO`doDNMIiMCKA`juSFeFkZ;P(p38db_50w7F>Otj$#9MIsd^rJm$`@1u zih>n`>SbfF;xlK!L8^Fq`a*F&A~$Qd+jT*Rm}%^ zUVZ}YD+Gy(yu7Z4RPcigoC7jY22_acvId13%ruC3D-h=CBFtNaFs~imJRgvGFF+M; z78dg)CP5v=^71aoYamDQybMB^XO3>(AG5#zcNl;MW~H#0_hKU4yk3NPObGLytD^aL z4ahtZPyn8?LiI1GJg#^Hs;4<#7Q6wQ`!WMjDd-~14}!=xAC!3M4r403oKu1pSB@a7 zR)FSn<3Uz|%$I zUjDZP*FOR;cf5wUe*;9@%NGdu=OWCX1d#=~za7R@czLH7&Hara^LymO7+%hYnI8c) zKLDcbDl1rqark0+d)Ps zfX2>1S4BWA1?l%d==VkFZ$j7a4$^ND8OHE372yPsehcJ10-)?C3sSkl614sSp%P*t zNIl0dwB-BN7&H_Jav3)^^)nWs`D8Ch{g;`b^$+IAfdOuxet4OIv^fVn-`ERMUoi`` z{sEi%2z2$aAoUwS<1y9P)O(=2M;E024XB&ujZM7;XlXlgCGgh>H1`i07m&uLJ_FtS zvmo^@ApgEL!{Xl^=;qG_sb4b%H2#lGJqNn_T#)(~pz-!@Z0aM>-D3+TiJBqsZ=w1*u;Ga(^{8^()ZBM;D}C0~G$= z*wja$oBvn;@BbY!pm8~AZ0b4C-G3IOJ_3{oOtE5F_}9~61niflM&NI?svB?MGH zd!T3mjkiSPB9&jD{?lJQ(212sp!E+Ziecr~G$i#P_nZZ(pP&Vr|1-kke+eNZpMuoS z1*x}S1Lc2g>R$*VsRxbE z(Sny-?}57XpoWpe%aiw@(IxQmA1JzDDGwA!k9Gh4-?0T`G9$#~ZfxdByi5g~hpclY zNavoJp$spN8zO~Kx9=NJJ0$cmk{3W0Re_Yh0gcYgKvsSRlpZ)_kirKPp1vT(Dxg8? zY!t=N_>w?ZFAGwi0&j-LvkS@B8-wAfz=H2;C31vE^5fCaLyu^|r25aC9U z#xtNnfb#~>^>Htdwi-j~KaiRWpz(~=AT^Mb3?aesBk=MldK5>2v`B#5Q-Pud6h1E= zAq6HVd~`vITR`huyipWG!{-OO`oG$L|L?d0Y9B~rQ?G#>Ss?Szg4B0dfYQG{Qrv=k z0B6r0@hK&bwNmbKybx@wXnje?fVOk@f^;kZ4X<^h>j3rdG(hToKfF``(a8Et zLHbHS`hsElKfs{tC;{|s9Hh($f9ykeC=D<4jQv;=$#WqA2Q2RTGQ=G#>Kfn15h^0M~^ zG>~~-Ho=%8FUw&}nU^^*rpn7i7*pqE7>Eh;HmHV*23faaMkvF}N)+qB^ZPq)B1IQy z-cwftHqNRH(syKfD8oxfh(1vIiAV!G>Se+kq;XbIy8EgQDhFnTGQ1RqsD`9Z4fOCj z3sP4CQukUL+4JD>1fG{aQo-hf1_gRSNfeacL|z8*{DXvw!%KG&&;;a%#)AtO7#Loj z1o4nPn+G!91QZ=T=*ENV0}bT*669`MkOm%5`5uj~0Tdq=$c+P#dR~xv50Lw{(ba>- zuQQNCAJmw*s|E|t%W9w@UQl>`)B^h)WIhMNzp|o8=>!yUi$EH7fYQkUum*7X&hgR} z6lK02Uh0CTQbFOv@{$R(>ITFVc)1)D;2@^R%R3N-%?A};ZUhxeAW@x{VxV0czIR^o zf$0}7*+5k|EC@l}Q*Ds7E^=WEFFnE5LQ_9DK0)=}QIHpXKfGMq2#qS1mrd zlr)NNL+ulJnGRyYOaetv4#=bzphf0gaFZZj0EPFBHmFXPm%1RGpfKTi*_4cw3qXdb zgAC~b4fVPr3<2rifzbaJ<~^R5PU!ldtAH-!0S!g7qUxW4(7zU;p9x+6a*%!o(9rZz z4Ono1({BYre=b7*p(Hf-r-Sr&xP>viY(>={fzYpu(BFivUmc`>2WV*46;;0lLjPM> z^5S{vgs%U&^56eEj(~=mSyA;%AoQ7-kF98j0x1#F5fzYpu(BFivUmc`B2Q-xKimHDH zLjT)qP^a*`bVAqvTmiH#)H{sfB`d1_83_Gr5&D_X^)CnMF8~ewA5}r|KY0BNDE)D~ zjJ*uCU*TmCjA`-G9mGT~4`V<^)ue_oysSbP1uhUl<=G2ZA878dh%Ak5nf(g`td6O3u`ayf{J?7ltnpd+I4!WdrOQigjK?!FF$ zdAT5+5c85?OpBM{ASSYTIUw`afQB}^u$UKtFi#ew6JnkajA`+b9mGU7PX=V3M@|^S zODinqX&}rydl4QVhhR*Lm)k*1Wb@9*{r$hApeu~wL4bvc{U*PbU^7j3X6Fh2=m^8E^LID_Xx(cczGSfL^kh@ z45;b{t@h-?V&08ex#Y4Nfh#6&i44#>PSp!~5*0W4cc) z1Y=sfGzT$}&GP}7_ar8a;bj&U^C}SL{RLgZ2r=&yjA`-mIf#jD-XCdDdIp7`6c+P5 z5az7~>4ccK2*$K{IUU4AHg65cJc0Z$hL@-0G5srnFfSIQ6JlNvjA`-G9mGU7FGd

0A43`;xGjubWX7tR+%(%_?nz5QmnaME|Hd9ek8`EW`TTSnn zx|xNV)tEgq`)Vd*-ex}4e2+OOeZ^Q@vv9MVW(g`qc&tFB)fy{MDdc0l&HAYI8|yHe zRGS`~Z#Jy9I^Y`g3^=Xk*j=-GYR6+=X5VVR2IL+ECWa~Cve48Z#sE~Z@fc1sTxxj6 z@S723HV-pTHt#aOX8zdR%);3s%VL|wVGA)!WlJy1X_kvEzgaR{ zX<3z7HCwS+3tL-Rw^>iN2IX`qn>3qZn`1VYZGPFf*#_G#v)yca%T~?K*sjfPvfVB_ zHhW?FH2Y%vS@zHDKie}HFflYRFff4fN|nJegUbe>oE>Gj%y6?In~|`Ql~J3~WTR(B zpN*u9(~OIa%}kt4!c0?5d!R9ga3hyRo5f^{T^4MXqLwz6-z-_JbgZsfJ+EAyH=8Z28Ta*#=Y_Y_mCRBW9~?TV~sAd(HN-t(l#( z-88$!cHiun?ZfPo!EKi}_6z|`3@aEI7(i+Jn!#fOGec*?X@-jpzZo(cg&8FqZ8JJ- zBxbB^TxQ&Ce9ibV*uT?E7MpxCVKxmjO*Y+Tde{`d%Z^&Su>iU2n&o3lGb?ASX;zD^ zzF9HD_giatYyzqU@0g^S7Mp%EWj2H4elc@p^D^^h^K0f$&3P=QSuD2rX2EP3W|?fc z&GIm~uK`QtY1YNo$E+_~tJxTXdk1@ z!Dh?MHk+}Ti<;Y*A2Yvfu4Z8jPV3JsK3lk123sz(+-%8aC2W;uRcv+4>Z;WrD@b1a zYAs^}YIWVQNwY1sJ!X5^R?W`TF2)Weo+m)kBXT^O8M+dc9!Ym0EG>pvCtGi`K5Q*! zqij=V(`<9i=CO^Ltuxe(kdgw$l?)6EFx?3%DcTGt8$L7q49>BzGzlsvju~Gy{$t!` zGTG#r$!8Nc(@@hIQ#LbUvoy0}vtwqL&D6||q2;TaMX<#(i_I2nmco{4mc^FGEH7KC zSs7ckSxttf%24YXXqtqSYv`$RGqg-AwVz|pumR#uNSd5#u!o2gx!HuxRM-@hCXbn3 zHdQk-HH$HOX7<_4%{c-3V-}Y!)GUoH+bkzrKC}F6>1GvdwajWW zxcp7CF14NmO_!5xp4oi0kpY*yY<9wSkd%4V?vEW(x;y|&m!SqV&{SD$c+BuJmUOw< zn9W4g#Kz>9$z>BYQ)5%ico#NLGcPrt1FfqFrOVIOh%!jj)&|_e`C|*J9iG{JwUdFA zKNlc*8<8%r8vHT99ov_U)l7^{aK-mkvp;5S=9A5znSV8xAv(58ZIDZ#&$e!M!SFH& z9M=yZZ4F3VBbPsrx(iYQT{Ze+)Mh*xsRRPWH>k#k#I~_no7rTH_y(oET~=<^q1H>R z*I9%5COqIe)y*~-oJ&A$?;3DVLI+aPd|(2%OF?C|nxUy-jG>v4t5J^8F|(UyW|q?| zS6YVJFfcHK+umWuX~z8~WoB(=>&-zj_pFZD+_d4dV-R2l_x;=qLk-)Erh-dOP(DgC zDFwGtKrIwd`vlZF0kus)EfY}xBh9kZlFdrg3e;Z#x%ip&S8zWJ)IS3CUYFTzwo|h= z1=oNK3d{@@;QBrk+yViWh2IQWjX?H^8LNUzK{FFqa2W`y=bxE=1&`T)N znSxt{Ape452UK5y+Fzjdg_xbHotV9|@0nFgOD99W)!w7KSAJnhEX8yvQ%}T<`%*Mk8 z)bjxMZW5Tm{Yo}NQNw3OUyaI)Tfw<^n#ocVP|qCZuWe>W%|P}t6fiS5fZHRj;NCGP zEI_&4%+wX!iwA`{D2~5bvRbKGn}S=KAU}deWx)0|KS6HHYzaMZFI)yuF*TA|3)mv{>BN$g~mhnZxUxSK|r7h0BCR$KO4F0kBa zdC2mzVxA6qy+s1E<{~Gg|$eXB`QnO0vc5U^;|&tFU%y>X95n#tdC=HJno+3{s5bx_ApxaRP+Wr2!ZFjU;1)M1@0XdknuB`x(=3)+ zs9Bm?g2pO9BMP9_HmDu~^^QQ}FrYLH>J@|f&ByGng8O~oG;@I&+=mDC{Xppy)CW;B zGBpDA)0?H@L%(j}DnY)@FGrwvcW|3;a@PU~@gn@wpRkBoBrfmKn7gfm&?WOrDy6;soS2 z&^Q*TYyhQqP#A#9KTsLeWjs zP#A*xmY^~WJXYiYv0Kf+)F8|-6AOHD1g`v>TQDK!q^oYx6@3Q znu5yKZ|1DvG!$l)3LYigW^>dA)Y=EdDMJIqZa0Ha1JJk^C{KXW2B^ObDw{!V4p16A zW_i^TR0n`&0zhfK&2Fk4c%*m&#BR{I9H{ICr7h410H_SSX7&_3LIoNR2Gt?cte0AY z^2#?`R&ZU#umEB=s80yWlc2Qu%=jyK#0OLdg7UyJi>=^s3pQ&}a9#uTrl#2~wL4~i z)t+Gk#BNZY2BqyV<5Xi%-2xgD1mz)6*$b+}Kz(^oUcF}X)CM#*2pZ>RH~_I5R3?D( z#xbL-MxeS0RDOecETFmd-LDR7+4<0UAF5wH85j4X9LNcmS~*ls7^BD3a@g4-mU?)d!%_6;N3<&1$LD zG3%?=pgI#&DuTy^7+Ar1tj%Dm0jO>U)nA}82-JE9&D(&+&8}HIwE(p>%&c9lL3J)@ zz5rCVd;^uG0ucSI2B6vv;>XmfLbb`S{qa@gGwjxNHGJ0 z0xLL=f<~Q>8D0gCih#ysLG2LGSTm@+eP;31Ld;4P+%f}|?4a@uG|IwY0I?f1J`d_Y zfy&Wo#!JEDz@SlAP5>0kjXxSh*m zpl6(BTw^@X43t~TEITYgISn-b0MQ5XFQ_~`W^}^{R1PsHuz~B8V|F*~>g~7Lp9G~T z12*tDYNWw5gOvvUhHZv34egCUqu2VzX~vbtDkfnjnI85 zqOF@uNgi!OfZ^ewA@I+*v%x|-8D1xk0I zat<^G0V*#*Wh|(y0@aJ4vIavxYwKKSF2(E7?urc^R+mzo7 zIgM(JL8XtIX@u!+vjb*F&CJX_%vW1%u-Iy$W@%wL+iHQ;Qmc>Ff;QqdN;ZBrF*cw) z4XV4qW#Ixgh6rf89aM*a$|O+T3o6S&Wdo=V1eK|v{0XXyKw%GZE2vHYl`){Y6x0p^ z<#bS;1{y;G=eG?Ib3t_rsH_5o3#g0-l^CG95meTK@-3*20=0obbvvl80F^zUIu?|Y zK=~h3=7Z{ZQ2z#;_71QygfK8Luo{3;G^q3jl?0%c9H=A#)m)&KF{suBnF^}4LA3y= zL;=;Fpb`;O^CO$ez`$?;VkW3;0fjlpt)Oxl)CK^BET|0usuw_Q5LjG+`bMB~22`(s z+zF}|K_wliUIn}J0mMvJa4!s0+Jb6!Q0pD!dr*rH)Up887NC|1sI~#MY(Oah)G`8v zD5&%T)s~=?1g>ov7(PJq3aI=9)z_dB802$MJb~H^=spM4L7?^ys15_Qmq2wOsJ#WM zL&0&xzz$AFpgI^-rh@8lP_aYq#vT1dXEpwFI?J+O7Jnu30^{`U{=| zXt(aSzGnT{`Y$-ux7+lC$FTm|fWo=mwjVqK{1-HDYrqaJKaLxKYzD;|XoM6r5(OG( z1dZH*MsdWfm8~gTUT8Y{mA z9=C}CkIUXNQZqI-jxt_myxI5`cw8jPWSPlklUv}?n<&#|rkhP~nW~u?n?->~7H@$^ z!=k`rO}D_Ki&5Y)l3U=>rYP|E;w|u)Sd`TkD;Dbz>m}A-tX*uT*gUZ@v2C%vVyj|T zVt2$HD-3n)AT*ui~#7K0FjB?ey%TnwieJ~1>gYB9QEqyiqrpJ)8V*u`Xu$rBS3 z(-zY!rYdG7W=G6K%u~#_n6p@fSS+#lV&P&r#qx=ziB*f$6)P3%66+(@A~qp5Q*5r- zh}eeMPO-gWD`FR7H^uIXorryi{S^Bv_6!N^3`ZCk7(@(045k=dG5BI2Vh9=!t}=XR z_!>N$;BFLX)MK>9=#0@DBOYTNV;|!j;~wKR#%GM*81tCunE06FnDm&eF*ySsHPi%; zbe#l;RHhkd)R5CW$GpdUjrke#H|9JRIuE2pRvtDd{*SgJSvdvi=&@91T+Y-AvyCrt(z%dMNH8L<1urtg6 z^~+3*O=3(yBmd`2K;!;>@KJvsBHeJt@{J{rm5!BURD`=GhjBW`5ZGmARWmutgPkl=c^RT)qlidT?2R>c}o|*}-KEnn9Qa&gYPMvRO9Y zY?y7ez_UiHY`@tu+i4-qlUadh5_W;|)B;G_7Bf&b@G_WYu-M=fczu%>c%}?B_nR3z z8)q4BGd^tm$`~}~Q3W2k{bk~28f;o+dd>8)DVJH8S+ZFdcy5c!Jk7k=e3tn$^Uvl| z;Bn?z;Q0?NOVBLRD(E~PWIPfv)3*znf~MIlwmAi!_ws_KAka)-lpScy?-n!#ZL>dY z{|e-X4Ujl6GjKM@0?#P@GJxby(75w2L(u$Jm(ew&$3|SnVaCbEUEncODHG6~$SiP< zlmgE!tpd;8Xn|+vR+)j;5LlUmMt66CN6M`%Kqc!bq?yW7mZ0(cC~z*kWu<0qY#jxj zeRySUX5(y=WdoYIdj+1!sREC!{sNEmR@q&%du+!Ap1bR^2hSBAfViIvJR>#>Jl`Z` zm}XdPI14;qqGbeH$+61ln-R0ImN96|cb74niLi+kcwBlHcy7$gbeid6(^KHw?1iQD zMa;CmvH;DIWr53*U*NI+Dl1S+>z5U1_M{73`*7KSW*)n2p4oi1k+KEN^31Y*X8YMz z%C5|=*=`kh?orFW%)Z%v6)5~KK++IsOx+4RW3~%C@^1y6fjkAC*Yh%(X0+Jo6qXtU zG`si8#LU#$Gz&Zn`3gKURRt~=e}U&Js=#x_T;LhfF7PZL7kEZx7I?No3OqkG3p^L8 zWesW*ud)Wsood;DO2l2@`A949Y~LD&u3umyLfJgXSl@Os<(cHsJ!#qjrJk z)}+AmL9@W4?^577z*XQmUM&mIJmo6zoRAfGzGWA9hRq5*n|jI$R9|~ROH$BWU=&J8 zy3O{m?JJa$6f~<^1uIDz7(PJK5oFFAGz-jSIHbx_1`cptFl5V80S<6Gfz+}TwDuqi zr7Q)_;QTU0E=wWn5s=GL&}^6#N?8h;ONWhrPrR|=&p z1+9iyg;JJ+W=yS6%2Lo;gHu>qvY=Hfu(A|1pZ^M_ECsDOs6r`AL37buC}k;V{&W^f zS^CYM!2#laW&(v`H60+&^$_QqY(Pmo;*m6twO$yq#;RS7zf>uePj%q;qHITX((k6xUYan$oXth)ov|j_Mi$Uub zxuE?TNL>tC`g0@LPs}3P6Ftwm`N&DNH&Vo2{E(yxKk#h^8RTF`zCq%H=n3fcwj*FfrGNberBf(dn03DU2D z)WwkAJ)~a)sf$7D>wbaP*LQ)()VORRy?aQ%22vM;)`m$z`!(O}86H5~52}kHy?f9a zPAfx5T?|=83hC8A>SEBE#Zy?u#XxH-UztMcVo2{Ev;wONyyor~w093$yT}Dz8`uTy z-Gf%$%>u6!lY;i{A-x*Vy0%r&-aTjy<1Sm!S}ZGQ?;g^tnP$J({**n#2S^@(l%tS7 z4QOo}WEJc!XrBhOGW3-Zq;C)D(;)ZlL1RQ+D1Cd-3Nk5_zCEN*16tb%>)V4?4O-zG z9fGt+L95+hqeGCsJ@V)fygkam3GNd>>SEA3URd8AGCqXdw+F4yn}yQ12d!?^Lh0Ls z)>DxobhmiaBpwUy-L)X$&B7fLx9uj}Hy{K8*v!{jhQrv>q8YJ_IR8k;jK1 zeB>3+z%>8LF=huqeGB#6twCaHaY|;M=|FY@b_sz zYnOkSgVxW(Mu$Lath-P~hd}GVrErc8;i`$DrBDJVcrO7Y{opEt5PJzw$EYEp51Lb2 z11@(Q%v;R2fY*eZSfyA^u{vV)#Y)9G#Ja_Li#2F|M%@-P*Rvcv>I|w^85kG}IKgv0 zp!NKqwJx9)sZl1N*`!k@f~H$cLG!7jnqbh54A8Dv&h6$YDwU1H;VFsB7T;QE_RYu#4P8wwygVyp?n24B~n1WhSwcr{A)P@4hd;T%o zVt&OOH21gM5>(59=6Fw7|ACJDg7y%|*t*!J*j@pzE~~O@x3jUYu%83jN4kI$ystvW zAi|)-V26Q-VT@sq;SEF38Xjfi3ga!{aXHAW)D!TEOBYiYvkJ2%W)|ih=04ET!wAbs zmNzW_SXNlAu=)Ys@jKP}1bCG*sBWqNuc`ZH3z{Wk*uV*1XAfFOy4GmB5oqnjUgP7& zcffNG(%_MT-Qc=C8r(YkZ3b!`R)a?@e}mIxHQ3JI7N9g)4X)dNTY^UJtHC4pzrmxf z)!>nW-{96sHMn*18$9<=4Ne8W!MhHt!Q;li!DAiO;P%yT(75FRPKFlH-b|BZlWOo- zHaEDwn+={1(FX67*bN@N@CMH&+y=KdvY~DQwOG5sEmmo8ZM_;i0%;B2EpZw=@)8Z6 z33&~54XCZe4ITrYZO3D;V}Hi}4af}_IKlIBJO(-jJ_b1kJqBwG&KSHg;4#!O^fAma z>@i$pc*gLJA&(JguF}^Cv=%_u7_=II*95d4;H}9T(=(=TOnJ<7%zVsp%zDh$n4K|u zW5#2yV~#v41!}D#uUBVy0I8cmV+}n9XADs7(lPQe${{!_x5ng-36H6bX^!a}(><{Eh`V*HW2}3u_gKGyx_XYy8Jj;gI<_&kHMVPP z@7VI#+1TaS&9OUU_s34hKE}QW;%Wv41}+qLpE3Ajpaaf}dko(g${5)g2e*&et3XKQBXZdYfw z&F;9}KRYvfcl$c~WA@iUdDwu9;RFK%1D}DLLAXJm!7+pD27HEYhT(>NhM=|6d`50Y z;YNK%$BeEU@fo`rha2}9A2Ysg%x3~xA=GDb%;dTWpQ)Q^xM`p1G1Kd&d}eND;bwhi z$IPyq@tM1shnx4AA2Yvh&S&9f5pL0Eam?bn1)rsxWw>RZ!Qa zTk%=DS%+KqSs$~$Zp~-oW)p7HXLHQvx(%PLn{BvlpY1W*>$ZG$Zg$~zeRjv}uG{h1 zyV-}^_d$H(FiiXrz{Su(v-p6lD**KsvZ1s2p!)rfjf`y!c*gjTEhw+of$~cN7kDkR zi~*?k-UA+acx{+tbOyZ6A;C*F2kxnuFHNf!0HcTFF_dTQM*&OyB~qzXq*r z0T(z|A1Qz`y`nuM1v*DZmY0I|XX*fYvyH z*35$Ho$IFWP5+p3n`wdf>w!!Mt;PbaA{7Vkg%z__vj*)*53^0PEwgI_uX)~Uf7SjG zD8DFhgV)We88{iV8O$)~GhGJWV+&eK3R*7&TX_Xq*9Kbe4QkVY+y`2B4PKF9zzu2B z87wsbt$zlsrv=rEpfyOKweg^}SD^L4pw*?Ib=08N5@?MlXk8O%ZwP3m6lfhdXnies zJ+%YGJlL8=(4GmM+oHbkG`O(3(-u8fDPRAb6Ms za6{HE8H9pYy@KKi)W!m}>p*LyKx>^r?M;w*pf&rTb>5)0aiEo4p#2=6Rj?p`gZ9jT z)?I_vUb)$af=V+6h6IRPSq(s|Qb8-vL8gON$$?fBgI0BcVh0ogpjB9))pwxvwV+jU zAQyvHb%9ocgVu?O*=d0H?sGF}fY$|f7+f=YVPt0NVG4>(&>j|0+5olVz-z`ExWVgi zLF=DED|tct5eYtUuM&3^UDt0(q&+n0I}nhVVF^- z(Jd3uy3AANW)_|nyR6i#Ev;ACirHy`+_HchoL^>v^FWs|XpeoB*)y}BW?7ckEMHni z*?{&$c|lfzZh)9+Wwgv_r;(QFG}D!)QWk9%GcCBR%d9)Cf7zzlRf5bs08#hKAj~k+ z@RqTgNu=0I{3RK+>Sg=$jFzah2&a)1RhU7S}9Z zT0~hNv%YEVWw*`lB*@GM5Hqa|ml^If)H0c7veHD#9F$MFtjer9t$x|0*;d-VvS;`J zF%#6nzhwl<(Wgv7t5J7Zs99QCuCf-h(X^Rm$7U}H$`cGc;CSdV1g*}jGI?h5(=dsEkie>NTX9GW~QE|yTGR@tg;fb*0i2w%VsA5@{a*T-891$hM?0O zwppC80F@1(G!5D_;A@e74aKPY*!3l#i25g2lh7N`< zh8~7Kh5_I+5h}pD-a#w#LAxlvS#nx&Sc6V1$gtUFbJFI7Et{RBodkFd2xtv0#OptYwA1rT?DLU)gmn6ajDKe(R-%8#IZ51_pZp#29R zJ)rfPpfUrr-te0xs}*R?Dk5FC+JJHoXiX$&jVY*10*6fl54djyDnmePVnN{pS{n(< znV=8??G*s^Izb@?T5}0nI}a+Kwt>$*N(H+Sw3-uCMuFC{g7$oXaw=%=1*rT3t?C4o z1EBS{;Qa&>co=fP`L-3jj}5e16qFx9YcWCnEYLc2P@MoO2|%kxL91Iqr2(jZ0PW8J zl?b5qsGu?jR4RbVTF{9Fptb*?wZ5Qrsi0M);5DBMAbtadF=%}@sMG;~dKXllg7!aw zR)~W3pn%q$g35f*2mxqM2B_Qz?f3%iZvd~mJpi$f6}$@(oQe#ef_D>vb_9V|^n%vk zf>z5?C8aPhT!7d|x3uzrj%nos#BX#@-k& z53~lKy5-7B+tqdl!FvuF9C*Qdqe1KEL3V-K6lrFqW{T!>%omt1F<)WMz`)SJ%fQ3H zz;N5$CBGV@Mz zUQ0KtH0w(1zcv<-nw5d!0xx*&`g;Q%BhVRmr_IeQJS-gS!TUEJ@PgZ?pm_<k8QTlCS8Q+C-m!gP`^5Hz?Hk({w6@| zqgz@jfY?X3w9-Jwv@!wWH@c;j1rYn_mR2_Kf%hsApH@Jl1)z}@Zt(m9Xzc@NbS41Q zk2$~x?*D@NhZ79k3?mIM7=lhu6)-+#eA76<1lF!!XXb1L+TR3f(}McWpp%gpEn(He%So6VX$Sf<*?1ZWz2U_+h|dC}F5!XkqAK7-5)USYg;3jWEeDsW9mI?QI6tuWhR zb^?5IE9k^h33Cl|3v&9Cn$v%+SF%?X`*l^fN*lO5X z*m~GT*k;&*&Y7KIyTW#d?Fri(wl8dd*mBrO*lE~V*m>AR*k#yN*mc;=umhb8dcy98 z-3z-P;4^PE>@Dm)>?7 zKB(`w!t{jc3sVj=4KokRb(VHkiq;Y~e{3A=T883|=D z;0L!4LHRb_sNSf@Xtoi913$PO3Od&TbVdQFuMQeh1ofX;K;tt3{NQ$|fRU_Gf>Ex~ z1Y^)ij9#WGrb|uP%p}da%$ArvHFGg9u-k5D0Lifo3<><;F# zCz#Dd%mmce1@)`Tt^2L#Sg*EbDBuT=0bMhAW&k<|0n|4JjW5WWn3_15#F>Eh)q+Ng z+Cbsh05Mz4Les*?vdwa)rHj=xtCdzE*2}DSTBq2w*-o-OWp~j|!d~9~hW&keh6xb& zTNv0IfWjR#1`6uWgZ9dUN=MKxP0$!JXdg9bd}5mIQd@=v5IeSmPt*jBuz^O-K<#GG z8J3_CF*X}Xn`yQy!RJAO_Ig9yzs=y7L7HJ1_-vIerpwLuo1ZZU&9R1BfX0zI>_OuJ z3l)h{XByWSHyQUB&oSO({LGlqM8?G2B*-M+WVy*^lOra4royID zri!K-ruwF4rnaUorrxGOrje!zrs<}6rlqDerY)u&rah(;OsAO6Fr8z%z;ub}3ez>F z8%(#D?l9eBdd~EY=`&LXGcGedGYhjAvoy12vq@%8%)XlcF=w{mvJkgWwy>~BwkWme zvsh!{WtnF=%krV6z13N(B+igDDSlc?-y4wbV_my9_{b$>0x6^LF-DA6#pt!ie z4?32X!Pz+2c%t!Q-sFnO50gaGPSg9Q&rRQ&{xLN$ zvo^~%Yd7mNyKHvTEYdu|Jl#Cce7X5%b8QQIi%5$Ei&~3i7OO2bS{%1HYw^J1nFW`n ztYxreq-DHix@E3qk!6?Vddt0*CoRue-mv^)*={w{YPr>JtJ7AOt!`R9wfbzuV$EeO zU@dN~X02mwYHe*DV4Y%JVqI%J$$GZ+LhF^*5;mna)i#H1F529-`D4Rq%VsNUn`WD9 zTWb5%_Lc2t+yAyKb|H4rc7=A;cDwBQ?Wfu=xBmbct9}5+9BEt^Zgv*s$1e*znj0*ofFj*d*Cx*yPw0*p%4ZvUzI5V9O4!OGRu=ZR2ex z+Rm_@W4pk1iR}v8HMSdUx7hx(1@**u>;&u>7z98^Br}K@m>W17W*b%-sv0{R#~3FY zXB!t7ml#(VFEl=G{M7i3@dx8C#y^bz7&Dl#m~fZ`nM9bxm?W5_n4B`XYVyJ4yU8CD z22&PORa1Y{MvS!h&h(4v57R%U3}!{<-z)?zbu2wBlP&8lXIgHzylMH>lEKQw>af*m zt5;U0)+yFUZ6s~gZ4GS$ZRgs)w6(Kqu)Aq@-|mxL4XC{$AOK!h;ASx0V4=YlgMP!A zh5|;qMs7v{Mu|ojjSP%u8}BqeZhX<$+T^gwWs@5wPfWg;{4_B)bvN|^*U7o2?@cAm zi_B-3FE&4FE@2U7vD@O1#S@Fy7E3HStpu!$tSqhWS>@S&uw81WZSQ8EZT|^muYv$L zza|(|8MGTrGgx4-$>5;D34@yk&ka5q{4!uS6f`t9%rGo9tTS9>c;4{7p@fmLk*`sn z(Hx@_Mi-5gj4O<18b_JTGTCk-XsTzr%JhWkQ&VO$1v3w`ezWIhn&$Q93(a?#KQ@=N z=(Jd5;bU21Im2?99!kekJ?_h{bI{&r(~CH*JZcTZl~QryIXdz>^|8s*az7s*e|sQuMaU00FPa> z8}J*{8qPB8G@54g#ORGtigAnaCF4)VD@_7Sb<8r%&@4ipEeh@u(c?*cw@n2 z#cw5RrDUaHWo6}L6>Jr4m26dF)nwIUwb%Bc?G`&D`$_go?HL>dz;n}!4cHAm4DT4` z8`T=M8(lDZX7tVIpOLAttFf(mG26n}GS;%ra-QWuOG#T*+eq70_6z|6;Ppzg3{D!%G+b`D(eRt0 zkWsx+ukknIMJ6Xr%uHKNEzMS#y)u(GuQLB@ZfKEj(P^>NV!wr_A&O2_6zOT*&ngL zZ2uJ$@&y76Zx|RDR18cEYz*8C3Jp39`V6KR%r;nVu+QMR!FPlI2D*mshJl79hLa69 z8tyQ>X((hQV`Og>V^m`_*=VlOUZXokuZ%t!{WIb;)-<*^_BBp4&Nl8gUTD0<_=WK= zV)ck(ej$*9m@xn&n#bAez5#v`P1^h zC9@T$6|a@BmAI9xm7;57~Br@=JpN!xaVwhGT}$jK3KF zGY&IhH=Anq!fdGpueF19ne`g$9Gg0u={BcrF4{b@d13R@=D&@Wt%g)!KE~t+eB_@3UuE04bYm4RQ>-4Hp@1H2h>3Zd_vAW_-%n!$j8f zta+owPK!qt?=8Ms7+MxuUbcK``PK5brI?kpm70! zt@c{|w0dCu$=b-q*2do^(WcJkhE29@v2B;_3fot8AR+~1OJ~r(&6E!cjYPb4r z``?z?j@^#ij^9q$PTWq~PTo%04iqYtb{Fls?f2O;9Dvjr8V1=0n+;AHFd3#8)*AL1 z?l9bMc+Bvu;ZwsehW`w?jYN%9jhc+M7@aq=H3>24F_~$y*kq&0E|ViBPfZd`3ryQg zXPRy{-EDfz^sec5Qz0{HGet8kGkr5VGgq@5v*~8%%vj9D%{PKi6b`pAx3st1Z~4R$ zw9Zq{s@!U#)lsX{R$r|6t<|lKt(~mXt(&b^TK}?Uu~D;ew289GwpnPm#qNaNdAkR8 z@9bFY`Rw)Wt?XUw!|W66o9uh-=h!a;rTq&6;C`2q!D7Q(h93;Yj3yYJHM(x}&B(*J z!g#9jX5$mamy8WfGEACGR+wm;&Nr1ei#1C#Yccy~cG&!r`ET<;izo|oODD@v%S=mc zD-$aRYfo!an|hlLn+-NxwvM*Wc0P8?>~7klhdr zSc2Cf-89fLj52&+7-+Q3=$(<2aggyz<6p)_CWfX3X60rV&3MhV%stJSEqE<7EF3Kx zEst70vwUkQVx?%MW@Tda$6CTh!A8|4(U#Rt++NmR(_YWs*xth4(SC~kO#2)5ckQ3q zzqbEk{}W{Q2S}OCW{_-H@a^0!N|lo*0{j9!Fa#% zb>oM|e~np8xJ)EWMnXo4MjA#(j4X^F7{4<9Y|LUJY$9di zXcA}=ZjxtWXr5=TXK8Qg3U0TTT28QJu@bbBv{JUxw9>cowMw$uV71rksMUF^t5&zI z-dTOMVzw5rmIb%gU9ID-859J;^9{3&))>hf&oka)Y-JK)^2%hN=~dHbrXNiInTngK znmL(ynB|&DTGUzeT2x!I*eKXI*o4_6+4R^v%h90<}1t(n7^_(ZF%4Fr6seKvXzZhm{p2Zoz)Dh z4OUyN9$Wph;@R*KQ*_o$g%ih@z+A%=BCYKn~ydk zwq~}Dwqdq0wwboIwkK^v?Dp9G29=8eg5Y+Zn?ZrW9D@f2Ukv^juo?0g&NUJ;7B}`c z%QRbVw!`d`nT5HkrI%&0WwB+QrKz=zwYzn&b)wr6dxgU4(X>@4g`?IziM zvE#GXv=6Ya0=4rJ1i|gRFoPn46$aZ4&KQIl78$NE+-`Wr@S>5laij4h<2lCc;54CO zVr$}QVs4sa%55fPrebDh=42LP7H8&Rm1Q-}YL3+wtKC*hY~I?evK6&6u}iS)v3qaV z4$6N8g5WcVm<RDA9W+{Iyxw@X@oD4h#&?Y082>XCG*K}zH_0|BFex>u zGU+gxWHQ5KvB_GK%_cid_M2QZxo7gk?Fq>|+$ZV6@9w$r@H;(>*zWvC^C)og1~8(o_` zn+6*_+u62)cF}g(b_@-I;B|Sr2Hl2?#s$V_j2+D;S+29ZWBJ;W!Aj0X$HvSi+$PUP z)=tIF+%Dg))UMjD(XQRD*KUg4Y`aBvEA2MeZMWNJcg*gb-8H*McCYO|*nP8Ou;;Ru zve&Y=vUj$xw6C{swePl{Xg}S4p8Zn$HTIkBciA7bKVg5t{)YVn``3`3=>$RW`ZERt zE(2KuC4+i{1qMqE&X_8jrI{&MJha$uz1RA%wXhASudvW|x$Rop&9>rpGIs0i_u78} zh4lhKa6QUk;9?M95Mz*SP-Za4V7tL#gG&at4PF?4+9x`OhK4?dfrbT!OAJpL-ZOk@ zSZdU2G}~yGk+`v}v8Hjf@eE^06K#`;CbLZznrt;WXp(2zZz^FXV!qW}(n8hZlZCU@ zQ>&j=+SZ^I{(jbx)``}itbbT@*+|>O*;Lz1vRP;I$i~)ohwXP;9XlI4@ZA<0AbI41 zA+ymMqu)mC#{Z0YOyW&unVdFVX7(;sGC=F`koEOaa^EZi+FTfDMRw47nN z%j%F-mdzg<4%=zA^K4hy?zDBai?L&PAP64wYcQB(u*6`S!3l#~25$`h83-6E8JZY^ zPG_EKm}qj;0HyVW-R7G=8@)!=9%V&=Kj`E)*05IF$qZ7S8U8^ zvd`p}iHfO#sgG&D=|a>0ru=5MW(8(tW_4ye%oxnY%r(uu&4bM6nQtlNe=Mb~^sG{?>a9*$HCivUPPeJCS!uK1=Bmv*8#Y@_TU*-% z+f3VH+gY}2ZLip7*%jN>+D)|EWXEqGW?x|6V87h{2zWQE5cs@3F#}_RLk7i$HHK}5 ziwsX0-ZFe)=x0=EbjzsKxW{;t@lIn+6GxLmll|svEEKHNtbDA3tO~8lt%PiR>;mjU z>>})9>=Nu!>@w`4K)1axFbD{N$7x*+5)HN)+%x=aC}k9Dy1-1@LeawA!q+0-qSQjh zYJ$xan;AB9Y!=uou~}iW#%8|VF1xFChW2&#vq0%WK?q#7aT}NzY%w@y;Aa?Q7-kq{ z7-yJdm}Zz|m}gjII179p(s@HuqYFlY#xcf!jg?G{Ow3JOO(&SnH(g^YZ8qDy*@Dq( zmenS!Q&tnKL1W{bc1!K9*gpcT@@HT$5CZQZ+5tYBTGY_O(9JNwaJQk25vUz%VzSo! zuf;=4HY-zWXKP>Ubn86pV(VJ#4(opFY1Rv@H(T$t-fs;$#qXZ=Z)-jqMH^ciUz-w} zg*Llv-r3mMM%h-`Ubl6&i?&O#E3{i=x6AIZ-37b5cER>3_HB@J9vy_hb3cX#js`&n zc?K1Rj}2XoLXD1EJhl+DRIs$LWVa5qZntK(QMC!TiM6S>X|s7~D{42{j>DcIKnOfm zn`f}oV4qQs@dD%J#(#{(O^i%@O`=V5Oo~h_%s}_v?X=XiXGjnNr{h%yI}8pPJT?$E ztTgF1F*4t2u4iFx8EV;VImvRBWx35{8(v#k+qJeQY#-QOvioYsZ!cyqYp-IjXYXPk zXP;?5-F}xnLxB*uzT`3hjVKoz)EG=Lm~XJcV2iA$~3{W z$8?$L8PnIMITkGzyDX}}CyRsn=?^X6TJl=iS+!eTvMRD&XZynTldXWArd^rcOuLnK z>+IOD9&d|+pli@kT_u!W3CZiq3$BZu+$C>1q zl$ksVN? z!tlHytC6Wum(gmYpGKm_X2zhlZI;fuMnufwF;)fvJI`fv-WNL5)GHL7%}zgR2HN z4elB|Gh5e`(HRVQvv+ zQERcl;;@CiWs>Du%O94`R{O2EtP8ApZ47LxZI0Qzv{AENWP8+Bz%JTuhTUU3J^M;< zyI&Z5ca(!cvcWn7Ekj?!F2k#a3Py8`_8V~-CmVk?mM|$aVK((MEi|2DdeM~4Ow%mR ztjBD-*()<%a|82K^I7J5%|Dr|Tf|sQv^Zw*+d|GV*s{ZNujKbLr{e!JHa5vHnQL;%gx%D}G~INP>0Z+p zrov`+W|?MF%=VkTG7~j-FwZuhW`5B8jk&mmlSQt@42#1S?<^!OT`co0XIUP#{9q|< z)h8=iYY*$=)^0YLHdAc&+q|+7wRNz~ww-2s(Dscjzn!05pWQXPUv^sd zQTAP+5{ZF9K^WX_Vl!|v$TFB^aK}K-FwU^caF^jLLn$LKqbj2_Ml!}l#)phw8B3XX znN*pqGPz~KWol)bWxB~!%Ph%kmf0z@UuIh7P3Ei2-dRbOkuClyk$z^3_m1Naq zwaDs_)gvn=Ya{Ct>#5dTt)E!S+l1Iu*{rg8V8dl=Yny93*Y>RKUt3+fSi4@ky>_4M zwCqdm84QHMZD&=3RD&jiMFxiq9vLthDj7N%CK)yvE;2l1_{fmSNXf{_D9dP;(J3P# zV`t+k<5kADjJZs#OtMU7nfx~~HH|XuHQi;(V&-kuW46nT!93A?oB1tsYl~8gr50B$ zSS?L0Q!S@j9<}^xscIE!)oQiX>Zz5ewX1ch^-}Ar)=V~9Hq|z#ZKQ3pZLisy*-f+i zW+!FuYd^vM0%T0hK^UAzwG5&Rx(s$1yfTn7^fIh6TxEF6kjuyl>at%(TEZsK#D=BMV>pj+Atd(rMY*yObvf;9Iu`RWIW1DEV+U|p$fqjAf z22d#yAPl}k!oZ-wV1vO20|UbX!wrTX3=ND5j5Zj3FfuSMFy3v;KG_M`8`%fh7uip;-(-IY zG%JxH4Bnq5WME_vWKd)<$zYSgC4)}}LWV|$L54+!lMFW*UNZb-C}d=06l7FnG|6a_ z(Iul#Mnc9$#zDqK#*>UUfyeuWOpHu|Oo~hxa>pho9s71_RSPP!dS?_$)Lz! zk-;ScCPO2`B*RIDhYUX%Dj5YCH5qL(dSs+yoMb%7_>l1@VWOm5xlbMQnj`=L}Q|7xV6wnO zz_h{igK2`<1v3Zp4dx0K6D$}k3oIX423Q@iGO%7?Enw4N^T8&;_JXa0-3B`a`w5`( zZGtd(4vWE{z~F&FfZ+i{1EU2-0>%x-AB+=BE|@r&ZZK6an_$LZUSR&fJiy|Bg@NS) zOC~E_t5~b$RyV99tRt*vSf8@~WG!T4WD{glWwXiVjg69RkZqOiT5!tIvCFZWWVg%i zm7SD*5ICH{XU8lM2G2|K8rT|?7|b&GY7l9-%Icli4b>CuZU1$IZW(t5|qhOtLs)!D6Xp8D-gJ zxyzE(O3Nz6s>^DZ)hjC@Ya{C*>mut}*7vOCY{G2%Y|h#6*@oJ#u;sS1vMaG$Vt2~! zyPcA~t$l+1bo)*AXCZsKHwc5z_;4}kGFS^P|78p#4eJe;8lEuxYp7u4Y*b*h(CCQK zD3vlO>ClmQ{dNw$*H_gH}(h1g*`jqpbU^_gg=; z=CHA`$+ekmv(4tF%@-RMTM=6oTN7IcTQA!X+c?_{+alW<+cw(?wzF)P*sizT3mR)W zAk6TFk%8fY;T6LhhIb4f7(Ow4Vfe=IgW(s$ABKMn8H`wrIE;9V1dK$CB#dN?6pU1i zG>mkN42(>SER1Z79E@CyJdAvd0*pe8B8*~;5{y!e3XDpODvWB38jM)@~uM*AlU{v30O@ zvGuU^u??^du}!c|vCXi}u`RGIv8}MJv2CzzvF(7)I}^W37&JF6VkcoIW2a!JVy9uJ zV`pGzVrOC3V%K5UV>iKWj@<&gC3Y+9*4S;Z+hVuFZjapoyCZfd?9SL-u)AV+!|smV z1G^`7FYMmfeX#pt_rvaw9fLiKJ%>Gyy@0)ly@b7ty@I`py@tJsy@kDvy@S1ry@$Pz zeSm$4eT03CeS-ZO`wjM6Pwm(;Y@VMiY#tz|-~$qcuhwjJ6ozD zMjwp682vE%W5i%AVJu^;V60-SVXR|pU~FP+VQgdUU_8Tkj`0HHCB`d^*BEaw-eSDN zc#rV`<0Hl=jL#TfFur1Z!}yNz1LG&gFECa(@R$ggh?q#2$e1XYsF-M&=$IIon3!0Y z*qAt&xR`jD_?QHkguqupWSHcb6quBlRG8G5G?=uQbeQy*OfZ>ZGQ(t!$pVulCM!(V zm~1fFVzR?zkI4a(BPJ(I&X`; zSZG-2SQuECSXfxtSU6a?Sa?|YSOi#vSVUOFSR`1aSY%k_SQJ>4SX5ZlSTtC)SaewQ zSWK{(Vll&Fj>Q6tB^E0z)>v$?*kZB6VvofEiz5~%EY4V5u()Dz!{Uy`1B)jXFD%|z ze6aXp@x$Ve1%oAvC5I)CrGTY~rG%x7rGll3rG}-BrGcf1rG=%9rGur5rH7@DWq@Uf zWrSsnWrAgjWrk&rWr1ahWrbypWrJmlWrt;tQz;pahEMHi@0nhUPu>51mV8vp^VZ~!5U?pNDVI^awV5MTE zVWnebU}a)uVP#|GVC7=vVdY~LU=?BosWVcnGOTi}3NY%9DJZqa2CFSrJFNCt9k4oL zb;9b5)dj07RyVBfSUs?MV)er6jnxOMFIGRS{#Y?svsiOj^H>X5i&#ro%UCN|t5|DT z>sT9Dn^;>|+gLkTyI6Zz`&b89hge5g$5m}AJtk+m?u-;<5!+MYP0qY~yC#=s{U$DMneZ%^W^#kiC)-SBzSbwnoV*LYS zt(1(7f{luehK-JmfsKicg^i7kgN=)ghmDU-fK7-^giVZ1f=vp1Jr(}iaSOD5BzASP zh^>UJjIDyLimisNj;(>MiLHfgh;4*z432uU$99746pZy-l-Hv+b`Ewfb{=-t>Y z9n_n1O?1w9ie>IMQg{KH66wN`3Xwx_z`~KQw#xqwN69k##D!0~ka`+W}9& z%)_J3jDqGZL#$$~Qmk^UN~~(ETC94krdZ9fT4J@vYKzq#t0Puttgcwyv3g?l#_EgJ zA1fAX9%~V68EX}59cvS78*3M9AL|h780!@49P1M68tWG89_uOAbF7zGud&`@y~p~9 z^%?6c)_1I*SiiCUV*SUO#fHa5#74$O#YV@*#Ky+P#m2`b#3sfj#U{t5#HPlk#iqw* zip?CGH8xvp_ShV;Ib(Ch=8nx1n>RLJZ2s7=*z(wl*vi2c2n%;*e$VJW4FZ)v>*D6-4(k#c2Dfy*nP44 zW5;68V=n?)gQg(Dpuxz%0Gn&aH**deGl$GJO9k7^xWP7?~K^7`Yhv7=;+c7^N8H7?l{+7_}Jn7)>#nW3+mW4~$e)UVRFIbhRFky7bYJ}ewZ+ra+nI3N|-8`YM2_B zT9`VRf_9Tdm?oHJm=>5;m^PSpm`*UAVY^UU8de5Y7FG^c9##QX5mpIS8CC_Ly)FSF;QIjtY#}Q&7!pJnY#13BNK0RY zRQU#EfxnX&RE>A zcw+Iv;*SO9>T6Qgs!7-onyqGFV3;7nFoB7I;gsPy!%K$O3_&YlVe4QYfX}Ps0k3+6 ztao(*ubu&&TG?Yf#dr;Ptt)Jm>l5QY#-KH=pw+B8CNAK$tB6&r4d9ikp!KPsRjF^l zt56~9PZdl-r&;=-tTU}Jod7;#4syEO5z{;1)uRk%EM`1rD&SS3koBPvW(DBYppbQ- zOU(9wSAD|PdwwzF0k7_at?P6FujK@tdD&w=#e5BTrRE9q2jF!akQE#v;5D0|voB-7 zYcnCMGN)Lq0k6RXt-b`UyZit?1ycsTzS04F7G@68I?5@QYb-&lCL!x3AArxrvS(s)Vfpc%40HwO|7HWX&G% zsctK54}eeH29?gRv$h$)r)+}u&x2O^`Pij^*YrVF&d;#h0A4E(TP6R(jsd(T9<&-B z)XD>`f(M(Sc83PmW?H7pk>;>R6S?3^~ zk$J@64tSM1Vtu-Vp#k`A48%J09K#mys&mMC^Bv$d=5N5`+8jm-;9U`*{SX1*Gh1uG z>%?amZ2+$d2dxK(owbL4A4&as2kTudJW52ItbI?jA&>AKk3m5QuWynh93X2Kgb;+O=$p^rv!M*{nJm#=e z0IxF!tuPJ%p9xz7UP(N|asznXFlfavat_e2asaObMqL5iVg=eW0y-xavC0>g2PCWw z;464Tz^isUz^inZSnmO^$-Mzi|Dcl!K_|!BfY;fAR@jz+&yVc^@4*M9d(ax%3*b{^ z|JZ;|0wyNKe*m9OA_LwZVqq5mJ_i7_ezgI7uIw7{zK|1k55T)XK>I%g>_Ml?+JN_Z zM1apCXaTP;T>w67_zZM^#~XWw4I&H=!2K4`UJlSM4if_(@SY9OZVk|`bI{%l$bBy- z3?6{@V1RaC2!Kx?wlM_V`4VAR0NztE#c+n<0`M8cXTUpwK)b&|`+h(>ehiE}!25eZ zJ0U8JCV=T?`M5e;9+( zGibMhhKU1sZ$gR*tbDIAnF8K}0NH(T!sG#XuK|lGq-`T%Y5?9-0NG8DVp;<}NfdI1 z=mzk~#gOtHbUv5}crO5C7l4OZ0(i|oWVQbkvo+wg{g74t56nPk8AHl<6>}YP7w}sB z4Dc%b3iAo(pt}$ttMQMR-vO`HgRIgM0H1Db16_+BV^IQLc@JB2zXrU{{sDMh{T~Yv z@G5%H`gs@281QO&)OGR;EJ17IuUI0lg=YYte+*gqZUbKJUI5-1)nf(P4+UDseh0j6 z9kgN{v{oIoN*%O59kDV!1H2l24tVwX4)BWeH{ccK0yZK@tIBP_E6EGM`>J|umVif* zLFZq?PQLzN13K**w2REb*11~ zQ15#Wcz+ONx7!EsY1=Z;U2Qf-Ax0_C^1H#P!)O6`Zx3Ww&lMv`N{6fvRsiqa2?4JH z2Ce>utovO6K85>?F=W5a8)Fvm?i|Rz91D{G@L8mg{WmQpbHKZ8Ap2}Cn7jb*s^J0e zr;#x=0q>qc?3*b7pH{jAd{XWK@G0GIz$cZWw`D+kT@t|iTc&{bvupsL*?kAPZ{?4f z2zZwYVt+~icuz_Tcn`_~@Cn{$pleg#n6rRaqC$3{SXcyr_nUy`p&G!ac|%$=M=Z`* zJOS??f$SWSurvVg6M^gyNwI{K;*gyn8^Gs#-+}J<_+u#o-roV)+2LW80N%#|+Wj{H zeAf3K@J@{zRv*CoGC-*uG#Y9H-hYt*9tUj!@3X+{tzH1{s$c=1IE&nNwXg|5*)vfC zZqID6L7e)2!{!6{jCUUJ&IizbLC}r|(Eh+F;B#p~y-m=~A)q@$K(~c(*kPu5&{Y-!3n2UWkjr+^_!K1NgZA#dv1hm-!XUy78j}L0eDty% zbtm2o@JZiiFm~H9fX|sn?5%SF@23NuH{S!@KL;!EuYh-bg7$iX%6kX!j!sxU0PS}J z?cxNL_@Gujaz2nTHZca3_>dLx8O9C9pnL$?$+pE9k`F-b7|_@f=uCPY=*~1BlN9hi zG{_FL873RR`^_Lb&7PS2F#+WR$c{1tQ_v~(kakRoX^rU=@Tt+D^P)kcM-RaJ!9eX8 z9y1X$9q_&{$c`^iE&%QCg6!;CV|E0*j|;Mc>xY>Dc)u28rxvJ1pJQHtu_J2>Gvjs=MyO$vQmVQ_XfOjcD zMs!@PW5Dei$O+67z$fBE+BTq>fiKpewmqabr(xp&-bDo2KU89aXx;3vIRHK*{|)rE z15i!??f!x6n~kt70PmEA?Dbh1KzRf0B+R>fbUqS zf$mA2W3UB$w;g2f=?en}@J>_6=(dTW4>$)v_L4S$Z(Uep2-!1w#_$Pv*E1*&2pCBi z8Gv^;L-sYN7(rU|pj@!RXao2jhC9%Goqvo(!23BNJ2^d!6Tmw{AbUYjd$-7~9~BeS z-fe}+1n>?_P~Ucs$q|z~;GLF`ksSe34e*Xi$X?1A(-QE`NyrK6D@+f7cSu6^Mt%XG zO{@Uj1Ly4SJCYzcU0BV zF~0)dsQ}rdz+s^P-j4{`i5Oy$1KxKC*>Si4e8a;T=+4477A)X>gpeJC7M20v{eqC4 zf-RPF!21FrI|46&?|k@U3EBB4V`T!~=Lgy0mtoalHNk2MxZMMqDLVt+w+Gp=#{j+s zLI=7t&j);RdWCg|HK=bp!+HaFza3WJjF=_+E$@=t<-&z~7ducJAF{h!!`=bBpBpk4RAS!)-a`i2)qMbbtH>MBD9{H;x@Rx| z%}{_&W(M6Y;$skC5MfXN-jNO2i@n5PkHHy(3(!5+AHesF$Uyg2+Zck*jRxH|0@_2} zVYmRiV;Zto8dUm&cKd_c`w~V9;G0K$p!@lAj9S3Eogw?2cNkp&?`nqZXJ#>$0q@DEb~@D5}?Ag^Y zcL49uh3w5OG4BEI#D(m^JpjJVGT?owkR7Q3;5$%i!08?|C%gr`&lIx5^o2D8`0RbiPEr#aAMn0W z$axA4;9F7FfKN^U%>X|E-*N+L@e9}@_i91&zBRU>J)V%$`8R;?Nx1{PGwqM92>9#+ z3p>zmO%J;S@ZLdDGPc_i7cLASc0NG7hVLt)9cM@`%!4dmA z;Ij)D7)0Uie+~ly@SQrKGYmmz6T}#lfKMWToI$X{;D7<>!~w`z178eyz$Xhp&J=I} z-?EbfJv*Ssa0&RN0LU2uHw-_3cOF8{w@@*%0iR|8I>#czr~rKL&K&6e{yj!lz`OY& z`}mQ2yP!F?9Anz{0WwS*!1rcAZp_$XdIr2B91E$8ED5kWUsmb`2L<4aBsK7yvBSA_~t*z-gC?mO;CFWvhzFve4|ef zbcZ>pw+m|TKz5S;NV>ytW)gQq30LegiP=orqp!N=Ar*wzS z0vp(94ruKIq`d=~S5pAr4CDjd?VMxV0^ZvUxs_sv?FI0SfuPnuXq^LOOb0Z6>0uWD zzALB(eDViqb;B0$Ss##7J}}2GLA#A0yNDaWw@9sl-rWly!xVs|eaKlI5(Wm~elO%q zjuZn(YX@@n#s=`cQjpP0(CN7%;1e|03IZHyt)CPQV1mw&JP~R8S+JW2@ zv&Zxb_#_C(O&uI&kk$_5tcMUYNNWdjro#g8ja6r$XE(etV*#Jk06C+2Fy2A=Gf+=DlV_^b5cL8$ZLWV^H_VXxgwF5bsK*So-+JTJo zB!F+e>Vcj#u*Uib_*?LG2yLF7Om%$S5b|^p*|a8`wanJ%jqZ ze~d-IXR<&}WAQLa0H3`AIdx@<$r|t(E1-ES(E16`ooqbNQ&ejFi3=hx<{u-+d(6c%&Sb=VPgUn%pR>PTq=dd7W zZ-7QPK__iM&e+&uea0Geq6XwF4F>T2Z#vL3Gkk1PY+$4K6KrPKKt_BZH~c-ZfsEoq z&blxF-v}22Jr}CR7BT8`0DRsn=#E&(okSvbka;V}$-W78pgZCqqduTDZAZYTJ3-EM z`e7#kKE(-ghLekZ4EXd2$hi^736aBu}=Y?n*up8WrqC*d(f;ce=EYI0DRgO?Tj z`B)vM3rs z-|Pyx)AfrD5BQ8D$mvGNvs<9m%}Z>zfbRnZjc_&h(zNq!vm3gB~uAnSfZ>~p~91wl>jTEAm^uDv4E^ufSi-2UtUM!J_!?a1}11_ z{~Fsp(DgbuY#)H{!-dRqf!6c8fbTNM0FQ50*i8Vhw1k{(3A)t`bdn|H3`^uS44~E6 zCE$~?AZKK)us>iAI;j$JM&%cKh6GUt7G?$p9`JdTkdr7K3_y1$=Ri-K>@ipZzRUIm zczpAQ!3Xd;l8_T5RSY3386YP`7JzS4o&!A*a*yE^@R_EN(@c?9>3~*N=YY>Cg`DQN z0DQml8R)5vZ;V*L=RiTuX|ym70H5~+x@oe;xW#x5_?$+_35^%PH!ed~t%;b(n3#ai zU4+~_nPJiZK3@@Xvf>t#GvIR+Atxv@fbU?2jBmP_`k1DG&qeG2uWFcKx&hqYft-B! z#Pp9T=$u2y35N#YTbUu_nwwQ8gq%Q_0KTUg zGQPRQdXMI9W`3wNxQVwbV zPcfTgwgr54C*;)57iJ9LGddxsbDEg@fY)zAPT_0--&+n@!+FH~jQJDrSzM4)xFjqL zz$b2k&e|k?#1pjQKLLCqChROs)R7<1N`D6M374R=Es;llDy$}e&pQUS|3Uk~5G#Bz zM?6ccA)`K^77*w}Nl?!hbEH22eD`?`__X9XHe0}V+as@B6S0-CH36TA3_1HL!?po> zj^hGb&`O6ZwxHFTe{31-1njW2eXy-`fX!}!PA&$edr;d4a#nGMeFONEM9BGwTfpi5 z1#DioL6jkek%0kpCNbnRV&rvfp!0?iqx`USnxJ)Tkn@8zz^gQ4z-I)5#yMf90)txp zCk!7zPqT)#dq8JagJyLTj4F&ktsYQnUt$EA)rF1p{4oNp@d51&0L|)x)+>WrJ%|(j zKx^7ys~bQwTgZJ~&IxgH|ywFh5{^#{7->4|CAo7aa>9iwN*;mmZ4^82ej9EKMvOEE6nqz~^`GusmY< z#uBt|Ma4?T%Ec zP+@|!S#%6Qvr?d5Drj6D)Jg}2rrXr>?rYfd7rY5E~rl8hGh-r*zifN81 zXoXFSX^-g=(>11`6nMn+jOi8d%6SGe5i<=l8?ykj6tfDm9Jg2fYy9~L~8 z3YI389+okd1(q$AGc4Cw9)t2tI1td3aSuzF*~U@c;; zVQmAxA-%%7$9jSF7V8t%cdS2Hv)D-3=-4>egxF-*fJ!^^_bGyQw1RfCf_Ab(W_Lin zJs0rKRnV?g(2iBmZdK4uRnRU~(4IrkenZe+L&!?>CE)#qckIEV84L^?L>cZdg4S?> z_7vI}xPbQ(g7y)D_7H;h4}$g%{xJZJT7z1#p!HcP;C+ISRfJsBU#z&0r7=w0HfXXKo6B`p3aLTAL z0j)g*jYELenSfSXv4B$pC?$YWL5*pP=^WD~rh805dnQ1wPf%^EVrF9onpX#nv$dGb zF$3+BIAV6k3^b<*8e;&hApxzVN-?i72aPFDF`r|;#C(nU7V|ykC(PfNe=!H`tONC| zK>O)xELy<3=s@cSL3`(TEJZ90EJG|SEazAruzX_4VWneb0^a)u+ATf9Y5{nU^aHCG z;GNML)&}7H(4Z0pG~>O)`T%(EGlLBWc*nDcO#pbGGibCIw7>a=%>(eRW(8Xf@LuK& z+XCL>Vj?85l$iEDT}{8Vr^goG^G}AOPO?83B&N1%@lYJ3L<)f_8Np7+DyF7*&9G zZyo^e*yJ!40PoWbFpe-TF|Gmc%LK*Q17j8w4HHm42JN|=0^Vl{%Dtf7l`7yJm7sh& z0h~W?nEo+k0q>V|G4nCYFzYd!0^S)3TIT@T4=H1=0^S9g0^a!uij52AU(6*eY%CHi zS}b}jR#=>|xB}k0C}JsNX<->-*ZR#W8h$rV$fl*#^8d%7Xt}H8^Z*{48s<~6^3UFKNyM_ zSs29_H5e^1I$`w2NWj>{IKsHbc!BW|;}^y}CI%)UCKV=gOb(blG2t-PF%2*+F`WTU zuMbRF%rwk=%nHn=nC&pTW5!^vV(wv{V?M!ri}?-nKjsP+E*2RUpnC0!#SaS^O9#so z%MQymmKQ9)SV~ygSh-jwSoK&fu-XEyziwE8QrritA65+39M%HX64naVptNUU?O^R; z9bg?{onQ?bi*2x;U_HZnf%OXO4c4Hvc*6REHE2J<4{K101dT}<*jU&&*nrYygiV4? zhE0J@g-wG^hYcu&F0ff)1G>QibbrMK8&Fz(Ve`S}hYf=*hb?F&1}N1U*n(DId)Nlp zg4Q8{(r<-rgKdZH1lt+53v5@|f>JVQj^ctXsK*XkjR#889CiYB5_Sr98g>SD7IvW2 z9bgw>mtdD+S729R*I)-q=b*ikE9^Gd?XWvwcft;o;vd+(u=`;5!;Zn8!ya_=u7bUW zy@9=jy@S1neSm$0Jt!9x*jLy$fbS%qVZXqBh5ZKm9rg#{H+{aa{{V_<28IWs3?IPf zU4T|^NEj#>Xc&M-wHypQz-yO4x5*Y5R2VcEbQnx9m|?KMV1>a3@crW_3@#YlFnD0_ z!r+6!4+9264nqM$2}1=#4MPJ%3quD(55oY%2yluiFsv|aFzhg#0N%dIuJDVJARH&}OI&FK%U zUs!*zhUIq9z1}d_ye-C{ov3q+SAfq$xMM6~0$HC6s)J)pa!g808sKLh95H!f^1%dj%7F^FArB!efWEM@}WvkP3zQp^g#rxh$QJ7RVLdOiV*vqANhg|!Q~?**!%mVnQRxncds8gVj=2S#nQ z!RCt11DhA%`bPwO{)>lg4!FGpY9A9i@x{OnwT|hr+kmxJQL%^hurlmB?5BY5IR>4_ z!N4HKumaky0-e8+V=w`H;>Hn!7vM8CWDFg^r)q#s)MzkVV7LZ+hQaKC@zn=^gMX6&z+FW+rA1W(j6F;5Nn)vomII%mmCqEiD)G40F&*x;fy} zC9as?G5=!z$DGAN0DPK+i$#h>0eFY@9*YweFD$-TfNsTdu=KIau>|c1=zyOJamMnE zVR7iE#P*;8rw6rH^416Q2QXlE(3fz&jLHp94=@K^M{=R_(T;@oe$cf4mm;P zfc*o|&A-v%^p z2#V<^=Af0r0u~AupgvBBMS=w=7jLmRVR6Ocj>Q*?KNc*Opq#8?X<}((>0;?)838^K zq{ngt)-ymraqnXl0?pH)`_PtHov?agh1wd`0k_IQr$Mc-hO|1->mn5!7jRo0blMZ7 zXM6yhyOCR%D&SrbwiBLKfKNF1VT;^~^ucn9(+;~EcG%jDCeV|33hbxgI(tV!4BQ`J zF%W>a4MU(QX@bEPwDWZYu(bbbpeO3=Fua513>^=n45JdG8Ah0`Iu^8Za$xlVA|*Y* zI1$GMJhB3*57wAm0iSyV8chL>q&S#nnAU(#xIvt5a|2vv{4td=Q!z6z3owf@YXOhK z?J>Jz_5gfdjR?3ta4`=sFEFnGkDVMazhDkZO)M5X77`W~7NBwibh^U~izOCEEG}4p z&UBEm)PSBXlVS-d*|;Pb#<*a(1c5cIIkuh*nY4D zr3V{3$ck4`Pol+c3AB`d0zSJ-0^D2hu`jWo0X}sJ)L;GsUfU$bAOhaMqhjCzK3S>8 zU;+3nr7H$M3_zzR=@@ad_K{--nsWo~j$Z>_U-!i9jTsNPTma21gqX*er-1jwgXY;b zm>)0)l?;E(1uP&d>0B&)EJ7?|z`JHZXLW1=mkm!W-oVQT8A}6j=@4U?0<9H#Ea!l4 zNxWcr$MTOQixrQRh?Rns2e@1)Kx)r|cD;i}Tv@Coz^BF`PK+yoo))*j`h@ixa4S^- zTqZ==6xh_*ECAn|h}rLyv30Obutn`@F0nlWKJDa-E#iDP&}xVn@L4AVFvh2lLZEQaGa}U0qysd z7)~)<0Pg8sG5ldDVT9bb3o$A&Y5@1f3%HhmoHsSae2e)3@Cj32%t5P(HNa;|#aMtwzj~C# zz-Izp0QX8*z+++-Hjt5r5}PT|IKKjJ5pdXQ*c#Z{Ku`Cpu$^JM1bm*~4O`F%0uT5E zKL_ZTL5JF`ED$!8~I2 z!t9ILA2S(q2Xi0u5c3lA8Q?L?Gv*(_?KTw)4{&}hv1qUW&3uE-`huPF1&S@uDPK00 zpuAcDKi6xE5$7>3 zu>W{31o~XL5v{=T&D9Notqb8kYZ3` z&;dRz4{=i76L1S2RL+YSDj0egf@VZOV>c@d_kc%i5Ti8`MjA#I;JzDZo(?uXvjV(E z161~ZFhY#TSb$e1<$%w(L!51Q0=yy*v@Qd5nw^J94EPK?#QAkQOiq~GFafm)K`Sv} zC)R=X8pBSjYcXA8dH_8C0ZKcdaaK@W0NP^=s>dPY;Gpr=Ip8xT&X_$gdt>&+47Bb7 z)E5A)y#UQMgKBlq{sLHg5wySljX8q_j|J$QAW&NoR4YL01kmYCpuJ?EQE^bK5wy+- zG*e;#ZZGD5@5}|A3be%%RNtSm1ns2<_5VP%f`pZWRS5W`IK(IiXdN|Z9u72)`Nj$~ ze*!v76mgCyXb1fg>mA@;A>!mv&!a8F61bhk>XkP&A)KAbJV9+cvXzpYJe2no5cuXCX!a(f=Q0dVC9v?=W&IsE5 z1#T}Ch%r21WMBZDdu3t}Vo(7-fpLw&0r0tth%*-Pq0iT2z03HDV zty}<|d$`Bsj>!uX&`F0f;8G?4e6}HI3;;A|b^u(~fOexRfX^?4)Dob%SI~)tN6em> zVb&5o@OhFK=9sm_1n60VXDr@WVAc{-EFr1k0=U!xl{v6l0(8bKqy>1w>WbADD^Lqi z!`cLVj%)^aBnwhYoUy)P{lgl$mdF904hw1-oPnMQ3#uhdz-Pc_fJdF@fKPqBVEel%q*BH$)IsiTg^NW!LxJB<{ zTwn}ZrM1NPgz**QJH~&EA#Fj>oI#68kI5R73*gyM7E=xI{AY}5gK3ZH6w@uHH%vio zJ|1X$FU73G4AlSI1I^hY<`&?Z9WJ4vMWm=Ab!F8w(c;&^a)uwfYAO0qALv zCYB-KdLqZN0)GDE9!t~80qyVv%_$hzx`1aA3T$Ds2%z&^4uH?Hdtu992b(tlt#t|jpJWGG=?9xBH~>D$ z1$2%bXoV|mZXf`Bjtl4%JJ7mr*lfT9&`cQv!vrz#m=1%13b>CKVNe4e@!w!@1w6(N z8Q+&NbTP~TpOZSr@BnyJ2XZPZhmnSni4k(1y`eufM(M~OifHdy|y0knWP6ypMXyxl`yk0^Dqkl&mns}idQ zs|8k|_P`A*25S{-Q0zun*MRfp2J0)ENtv3tsS%jcbIMB@X6FUxj5qlYX8+eO+hW!rvBjD2p85kHA zh%s0&f!5*37`PaKP8bB8AqASN2F=TWPP>K8$iVLL766}h3!0AsopKACi2{c#29p@?Hgkr6VQrG&{=|z^K4yAa!e+e%rODYeV;IS zVe-X91ANX-2KYn;(B9e&rhC9W_8+F8aXuL{6EhdH5a{W%kkSCOw(N}A6*ExJ?}r&I zO;mtKayOWRW>-O{$U;t#1=a2W;4!}q7JDpifJ<)+__)s+%N@|OU*A}Mu>_s`3hKLi zfX{kGT|>iRjahD=u>N2zVxwTA0X@~b20WX%!UoiHe_+F4%VVo!YXPpILF?H;Cw44= zpVbYTC4`;S4a)1Fb-kc;0-6~tv0DK?llug877(<~K>~bcO$2z(uLV5cx5gf{V-K`` z_XnsP-vBAcWx(@$pgZG1_rxzSIAHL=fWc6~(7`alu)(m$aE0L(!wZHV3$i7Tw+oKjz!Qp8JH_u zB=DR&ya#;V@C$HH08~5sm_hpUkUrcFGf?de%Igy5kUkvf=I#XWh%RVF1L)-7HRh1> zf+76_P_G^o$DkALKxYK^fY*s%u($(0braS*$N-=ByT$T~(0;;b;^SLGlpj9ma1_cH+26GHn7(4)yJ! zf=d!SuRpwntVYua6GA!pWrPND>z;sn{zT3`#=-PB+US?i8^Z#8Jo2WaIx>|C=e zwl{3=fcJYtPWgcB`UdR<0iFB=TNSAQKL0?+&H%h07IX>%=AG4`y@8;!5YE`Wv4iXm zVFB+71nmGvJ)Io1F8&7egufTyQxLvD`dJUe7`8AlFpz&TIcVQ2WY;w0yd=m@A{jFU zvjb)i%>I}um^+v!m^YZOF~4FCnz8V)$gx;ramPZ$(#NvJa*yQ~OC75et2tIztaz+F ztY=tXu;#Eyu-RcFV4Gokz*fZ0$F9Y0kKGqL1N#>HJ@(+ej32}pW`NzCVlc@L`G*gM!)*l)0ZVb8!I4tAGBm`e9^XoMF7c_=d57iHAvp$qthbCK{#*rW;IOm@1e> zm`yM{Va8x?VP0Uq!u)}`ghhZwhs6Pl9~K6dpi=0DrGS-(RfE+Is}EKh)(Ox!bg-$g z*;vpO><>WFp8~{f1_l`h3k+@;2pD=8HW=6>FnwSuVHRN4VRpdmhnazS zhWP^X8|DHQ9u^H2J1jm}Xjmp#&ak{-$zkPSRbjQk>V=hpb%gZ<>l4-tHWoGoHY;o% z*htt0*ml?+u>D~RD#I4o-LMm|_pooU-vMb~8i+G2U|?X-FmN$QFqmNgN@+fZ9foTR z9~kl&*%%cVZ85rG#A0k3{AWuRl?VNzqV#N>vFgsG2d19%2Vzzj4pw8!j= znT)xMd4>4}a}f(4ivo)o;8|GE*j$d~1n_(fsMW4x1*)s(Se>x~jpMjj*H~|`7O*L> zSz>d;M#7fEF2Ih#-ot(asD5-1XNX{6V307VFt}i#VR*r?!broo0~%5{Od3p8%reYw zm^qk()@fZZm#`?XIAKv?sbQsHEn;I~(_!<)#=y41_JFO0U5DKTI~n@~`yC*21H>6( z7#J8L3}zVIFfcL9Fzhh=Vd!DhW3&V8+X~|y;G8wV5YiG}G4QwOsdW*+7m;MG(fmK!V$tUg#b*v_ysu`jScV9!th)BnNXf+2(P2IC0O z%>kwrW)kKV<_F9TEbdq^SnjY)uv%hu!%D$A!&O zm|-Dcxx$jeiov?W+QMdojfQQ3t%BVIyBzx&AU7=#XD|V~X@WtA;R2%t#xG1H%yyW0 zm@hE5un4exVcB4H!79Rffpvq8g{^^I1W3;Yh(9hE>@b{Q#9$l&w!Ol{z;uPFfSHR~ zgV_bM0CNe84hs&;3ziyIE37oES6D~b9I$b)6|ift`(Wo_&u~DT!3JC|EHF?o{9ssM z^ucI?v4F_~lK|5RrUGUY%o5Bmm^)b9uqd#6U|C_sVI5(^VcTH)!nVVX;Q~ajhQS8| z3BwhJ7DfWb1;#gw6HLCC7?^69WtcrM`(eJpBEfQn)eoBha0s5TE3kh6a{B{_e=Q6q z82m5@FkE5CU=(2#VH{x+VH#l;VIE=e!GgnThgEzEvm2HL;Fz|sv9P^hn_&mmDFD$o!(fKt45JywGfZZHOXwA59OgI7JuDO~ z9jqo;X;?q7PO$l5v%%H_qKkn+K?0n%0}L*JQ$~W(10xG#4wDNe8Kw$m9cBXN8DRYq zmNP6FtS(qNSZ}ayu=!wpmSw=Y&2{i*jCsH*q;E!MF7Ok1cM(28w@>+9vICqE->K$o&RQ*VXk1Y z!y>?v!|H)mg|&f=gY6C533dUHJdhy4U;ygc8CV!zFv>7iFnM57VQOG@!t8~4gN23V z56cNw9@Ysq9CiyJ>9s%toW?B-E*NweIvCwBnqaJ9qG76GreUsOp<$_Eb-*eD9Crz} z5_S@h^0xuvwhjXaLkA-V;~T~|Om3LoFe@|ndaGK_@?|`^%0wg?k z7vUV)nyK!ra0<#=ORSf%zTq`cnss6pI-aKP*%%BP?fFUa@4bGO^0BT4Hs@>W`I) zb%FH`>o3+iHW@Y(Z1&iEuu-uMv26jjt~~4->@L_b*sIvv*caH(vA+Upk3W!L@BrIe zVz9#Cf&q`AgJFT;6vGpSJVqWyEk-+xUKq(3dl=UkuQ9%2%wytVvI5+eaWJhgU1NI1 zl*i1)ti)`C8N( Date: Tue, 27 Aug 2013 08:12:30 -0700 Subject: [PATCH 055/782] Binder fixes --- Rx/CPP/src/cpprx/rx.hpp | 72 ++++++++++++++++++++++++----------------- 1 file changed, 42 insertions(+), 30 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index c97b322..166dc81 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -45,19 +45,18 @@ namespace detail { return b.obj; } - template + template class BinderNested; - template - class BinderNested : public BinderBase + template + class BinderNested : public Base { protected: - typedef BinderBase base; - typedef typename base::item_type item_type; - using base::obj; + typedef typename Base::item_type item_type; + using Base::obj; public: static const bool is_item_observable = false; - BinderNested(Obj obj) : BinderBase(std::move(obj)) + BinderNested(Obj obj) : Base(std::move(obj)) { } @@ -65,17 +64,16 @@ namespace detail { void concat(); }; - template - class BinderNested : public BinderBase + template + class BinderNested : public Base { protected: - typedef BinderBase base; - typedef typename base::item_type item_type; - using base::obj; + typedef typename Base::item_type item_type; + using Base::obj; public: static const bool is_item_observable = true; - BinderNested(Obj obj) : base(std::move(obj)) + BinderNested(Obj obj) : Base(std::move(obj)) { } @@ -89,15 +87,23 @@ namespace detail { } }; - template - class BinderConnectable + template + class BinderConnectable : public Base { + public: + BinderConnectable(Obj obj) : Base(std::move(obj)) + { + } }; - template - class BinderConnectable>> + template + class BinderConnectable>> : public Base { public: + BinderConnectable(std::shared_ptr> obj) : Base(std::move(obj)) + { + } + auto ref_count() -> decltype(from(RefCount(obj))) { return from(RefCount(obj)); @@ -106,15 +112,21 @@ namespace detail { template class Binder : public BinderNested< + BinderConnectable< + BinderBase::type, Obj>, + typename observable_item::type, + Obj + >, typename observable_item::type, Obj, - is_observable::type>::value>, - public BinderConnectable< - typename observable_item::type, - Obj - > + is_observable::type>::value> { typedef BinderNested< + BinderConnectable< + BinderBase::type, Obj>, + typename observable_item::type, + Obj + >, typename observable_item::type, Obj, is_observable::type>::value> base; @@ -274,20 +286,20 @@ namespace detail { } template auto multicast(MulticastSubject subject) - -> decltype(from(Multicast(obj, subject))) { - return from(Multicast(obj, subject)); + -> decltype(from(Multicast(observable(obj), subject))) { + return from(Multicast(observable(obj), subject)); } auto publish() - -> decltype(from(Publish(obj))) { - return from(Publish(obj)); + -> decltype(from(Publish(observable(obj)))) { + return from(Publish(observable(obj))); } auto publish(item_type value) - -> decltype(from(Publish(obj, value))) { - return from(Publish(obj, value)); + -> decltype(from(Publish(observable(obj), value))) { + return from(Publish(observable(obj), value)); } auto publish_last() - -> decltype(from(PublishLast(obj))) { - return from(PublishLast(obj)); + -> decltype(from(PublishLast(observable(obj)))) { + return from(PublishLast(observable(obj))); } templateclass Allocator> auto to_vector() -- GitLab From 1dddb22b63443c7b299a85918c578c5b6b79ab01 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 27 Aug 2013 08:13:18 -0700 Subject: [PATCH 056/782] add tests for publish, refcount, publish_last and multicast --- Rx/CPP/testbench/testbench.cpp | 75 ++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index b43b39e..d860a89 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -232,6 +232,80 @@ void Merge(int n) })); } +void RefCount(int n) +{ + auto loop = std::make_shared(); + + auto values1 = rxcpp::from(rxcpp::Range(1)) + .subscribe_on(loop) + .where(IsPrime) + .select([](int p){cout << endl << "producing: " << p << "-> "; return p;}) + .publish() + .ref_count(); // infinite (until overflow) stream of prime integers + + auto v1 = rxcpp::from(values1) + .select([](int prime1) -> std::tuple {return std::make_tuple("1: ", prime1);}); + + auto v2 = rxcpp::from(values1) + .select([](int prime1) -> std::tuple {return std::make_tuple("2: ", prime1);}); + + cout << "Merge 2 subscriptions to published primes:"; + rxcpp::from(v1) + .merge(v2) + .take(n) + .for_each(rxcpp::MakeTupleDispatch( + [](const char* s, int p) { + cout << s << p << ", "; + })); + + auto values2 = rxcpp::from(rxcpp::Range(100)) + .subscribe_on(loop) + .where(IsPrime) + .select([](int p){cout << endl << "producing: " << p << "-> "; return p;}) + .publish(1000) + .ref_count(); // infinite (until overflow) stream of prime integers + + cout << endl << "Subscription 1 - published primes:" << endl; + rxcpp::from(values2) + .take(n/2) + .for_each( + [](int p) { + cout << p << ", "; + }); + + cout << endl << "Subscription 2 - published primes:" << endl; + rxcpp::from(values2) + .take(n/2) + .for_each( + [](int p) { + cout << p << ", "; + }); + + auto values3 = rxcpp::from(rxcpp::Range(200)) + .subscribe_on(loop) + .where(IsPrime) + .select([](int p){cout << endl << "producing: " << p << "-> "; return p;}) + .take(n/2) + .publish_last() + .ref_count(); // infinite (until overflow) stream of prime integers + + cout << endl << "Subscription 1 - last published prime:"; + rxcpp::from(values3) + .for_each( + [](int p) { + cout << p << ", "; + }); + + cout << endl << "Subscription 2 - last published prime:" << endl; + rxcpp::from(values3) + .for_each( + [](int p) { + cout << p << ", "; + }); + cout << endl; +} + + void PrintIntervals(int n) { using namespace std::chrono; typedef steady_clock clock; @@ -399,6 +473,7 @@ void innerScheduler() { int main(int argc, char* argv[]) { try { + RefCount(20); PrintIntervals(10); IxToRx(20); PrintPrimes(20); -- GitLab From 769b889472c700a4d29ca4fd528f56056240f11e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 27 Aug 2013 08:20:38 -0700 Subject: [PATCH 057/782] fix windows include guard --- Rx/CPP/src/cpprx/rx-windows.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index fab0dd1..5284744 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -7,7 +7,7 @@ #define CPPRX_RX_WINDOWS_HPP #pragma once -#if defined(BUILDING_FOR_DESKTOP) && (defined(WINDOWS) || defined(WIN32) || defined(_WIN32)) +#if (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) && (defined(WINDOWS) || defined(WIN32) || defined(_WIN32)) #pragma comment(lib, "user32.lib") -- GitLab From eb24962d810c2e2a0ab36deae1e7da0b5014808f Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 27 Aug 2013 09:46:03 -0700 Subject: [PATCH 058/782] fixes for clang --- Rx/CPP/src/cpprx/rx-operators.hpp | 14 +++++++------- Rx/CPP/src/cpprx/rx.hpp | 6 ++++++ 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index bbe35eb..079d957 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -1961,18 +1961,18 @@ namespace rxcpp { struct State { - State() : refcount(0), subscription(Disposable::Empty()) {} + State() : refcount(0) {} std::mutex lock; size_t refcount; - Disposable subscription; + SerialDisposable subscription; }; auto state = std::make_shared(); return CreateObservable( [=](std::shared_ptr < Observer < T >> observer) -> Disposable { - auto subscription = std::make_shared(Disposable::Empty()); - *subscription.get() = Subscribe( + SerialDisposable subscription; + subscription.Set(Subscribe( source, // on next [=](const T& element) @@ -1988,18 +1988,18 @@ namespace rxcpp [=](const std::exception_ptr& error) { observer->OnError(error); - }); + })); { std::unique_lock guard(state->lock); if (++state->refcount == 1) { - state->subscription = source->Connect(); + state->subscription.Set(source->Connect()); } } return Disposable([=](){ - subscription->Dispose(); + subscription.Dispose(); std::unique_lock guard(state->lock); if (--state->refcount == 0) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 166dc81..efecd89 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -90,6 +90,9 @@ namespace detail { template class BinderConnectable : public Base { + protected: + typedef typename Base::item_type item_type; + using Base::obj; public: BinderConnectable(Obj obj) : Base(std::move(obj)) { @@ -99,6 +102,9 @@ namespace detail { template class BinderConnectable>> : public Base { + protected: + typedef typename Base::item_type item_type; + using Base::obj; public: BinderConnectable(std::shared_ptr> obj) : Base(std::move(obj)) { -- GitLab From a3d5e94addf02aaed3e59d4048ac9410531dc231 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 29 Aug 2013 00:40:43 -0700 Subject: [PATCH 059/782] Rewrite RefCount using Sink and Producer --- Rx/CPP/src/cpprx/rx-base.hpp | 6 +- Rx/CPP/src/cpprx/rx-operators.hpp | 258 ++++++++++++++++++++++++------ Rx/CPP/testbench/testbench.cpp | 16 +- 3 files changed, 225 insertions(+), 55 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index eb5cf5e..1ad3966 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -15,9 +15,9 @@ namespace rxcpp template struct Observer { - virtual void OnNext(const T&) {}; - virtual void OnCompleted() {}; - virtual void OnError(const std::exception_ptr&) {}; + virtual void OnNext(const T&) {} + virtual void OnCompleted() {} + virtual void OnError(const std::exception_ptr&) {} virtual ~Observer() {} }; diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 079d957..94a3cd6 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -182,6 +182,141 @@ namespace rxcpp return p; } + + namespace detail + { + template + class Sink : public std::enable_shared_from_this + { + typedef std::shared_ptr> SinkObserver; + mutable std::mutex lock; + mutable util::maybe cancel; + + protected: + mutable SinkObserver observer; + + public: + Sink(SinkObserver observerArg, Disposable cancelArg) : + observer(std::move(observerArg)) + { + cancel.set(std::move(cancelArg)); + if (!observer) + { + observer = std::make_shared>(); + } + } + + void Dispose() const + { + std::unique_lock guard(lock); + observer = std::make_shared>(); + if (cancel) + { + cancel->Dispose(); + cancel.reset(); + } + } + + Disposable GetDisposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = this->shared_from_this(); + return Disposable([local]{ + local->Dispose(); + }); + } + + class _ : public Observer + { + std::shared_ptr that; + public: + _(std::shared_ptr that) : that(that) + {} + + virtual void OnNext(const T& t) + { + std::unique_lock guard(that->lock); + that->observer->OnNext(t); + } + virtual void OnCompleted() + { + std::unique_lock guard(that->lock); + that->observer->OnCompleted(); + if (that->cancel) + { + that->cancel->Dispose(); + that->cancel.reset(); + } + } + virtual void OnError(const std::exception_ptr& e) + { + std::unique_lock guard(that->lock); + that->observer->OnError(e); + if (that->cancel) + { + that->cancel->Dispose(); + that->cancel.reset(); + } + } + }; + }; + + template + class Producer : public std::enable_shared_from_this, public Observable + { + public: + typedef std::function SetSink; + typedef std::function, std::shared_ptr>, Disposable, SetSink)> Run; + private: + Run run; + struct State + { + SerialDisposable sink; + SerialDisposable subscription; + }; + public: + Producer(Run run) : + run(std::move(run)) + { + } + + virtual Disposable Subscribe(std::shared_ptr> observer) + { + auto state = std::make_shared(); + auto that = this->shared_from_this(); + if (CurrentThreadScheduler::IsScheduleRequired()) { + auto scheduler = std::make_shared(); + scheduler->Schedule([=](Scheduler::shared) -> Disposable + { + state->subscription.Set( + run(that, observer, state->subscription, [=](Disposable d) + { + state->sink.Set(std::move(d)); + })); + return Disposable::Empty(); + }); + } + else + { + state->subscription.Set( + run(that, observer, state->subscription, [=](Disposable d) + { + state->sink.Set(std::move(d)); + })); + } + return Disposable([=]() + { + state->sink.Dispose(); + state->subscription.Dispose(); + }); + } + }; + + } + + struct SubjectState { enum type { Invalid, @@ -687,8 +822,8 @@ namespace rxcpp private: ConnectableSubject(); - Subject subject; Source source; + Subject subject; util::maybe subscription; std::mutex lock; @@ -709,6 +844,7 @@ namespace rxcpp auto that = this->shared_from_this(); return Disposable([that]() { + std::unique_lock guard(that->lock); if (that->subscription) { that->subscription->Dispose(); @@ -1953,61 +2089,93 @@ namespace rxcpp auto multicastSubject = std::make_shared>(); return Multicast(source, multicastSubject); } - - template - const std::shared_ptr> RefCount( - const std::shared_ptr>& source - ) + namespace detail { - struct State + template + class RefCountObservable : public Producer, T> { - State() : refcount(0) {} + std::shared_ptr> source; std::mutex lock; size_t refcount; - SerialDisposable subscription; - }; - auto state = std::make_shared(); - - return CreateObservable( - [=](std::shared_ptr < Observer < T >> observer) -> Disposable - { - SerialDisposable subscription; - subscription.Set(Subscribe( - source, - // on next - [=](const T& element) - { - observer->OnNext(element); - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) + util::maybe subscription; + + class _ : public Sink<_, T>, public Observer { - observer->OnError(error); - })); - - { - std::unique_lock guard(state->lock); - if (++state->refcount == 1) + std::shared_ptr> parent; + + public: + typedef Sink<_, T> SinkBase; + + _(std::shared_ptr> parent, std::shared_ptr> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) { - state->subscription.Set(source->Connect()); } - } + + Disposable Run() + { + SerialDisposable subscription; + subscription.Set(parent->source->Subscribe(this->shared_from_this())); + + std::unique_lock guard(parent->lock); + if (++parent->refcount == 1) + { + parent->subscription.set(parent->source->Connect()); + } - return Disposable([=](){ - subscription.Dispose(); + auto local = parent; - std::unique_lock guard(state->lock); - if (--state->refcount == 0) + return Disposable([subscription, local]() + { + subscription.Dispose(); + std::unique_lock guard(local->lock); + if (--local->refcount == 0) + { + local->subscription->Dispose(); + local->subscription.reset(); + } + }); + } + + virtual void OnNext(const T& t) { - state->subscription.Dispose(); + SinkBase::observer->OnNext(t); } - }); - }); + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer, T> ProducerBase; + public: + + RefCountObservable(std::shared_ptr> source) : + ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::make_shared<_>(that, observer, std::move(cancel)); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + refcount(0), + source(std::move(source)) + { + subscription.set(Disposable::Empty()); + } + }; + } + template + const std::shared_ptr> RefCount( + const std::shared_ptr>& source + ) + { + return std::make_shared>(source); } template diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index d860a89..6122fd7 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -237,9 +237,8 @@ void RefCount(int n) auto loop = std::make_shared(); auto values1 = rxcpp::from(rxcpp::Range(1)) - .subscribe_on(loop) .where(IsPrime) - .select([](int p){cout << endl << "producing: " << p << "-> "; return p;}) + .select([](int p) -> int {cout << endl << "producing: " << p << "-> "; return p;}) .publish() .ref_count(); // infinite (until overflow) stream of prime integers @@ -252,6 +251,7 @@ void RefCount(int n) cout << "Merge 2 subscriptions to published primes:"; rxcpp::from(v1) .merge(v2) + .subscribe_on(loop) .take(n) .for_each(rxcpp::MakeTupleDispatch( [](const char* s, int p) { @@ -259,14 +259,14 @@ void RefCount(int n) })); auto values2 = rxcpp::from(rxcpp::Range(100)) - .subscribe_on(loop) .where(IsPrime) - .select([](int p){cout << endl << "producing: " << p << "-> "; return p;}) + .select([](int p) -> int {cout << endl << "producing: " << p << "-> "; return p;}) .publish(1000) .ref_count(); // infinite (until overflow) stream of prime integers cout << endl << "Subscription 1 - published primes:" << endl; rxcpp::from(values2) + .subscribe_on(loop) .take(n/2) .for_each( [](int p) { @@ -275,6 +275,7 @@ void RefCount(int n) cout << endl << "Subscription 2 - published primes:" << endl; rxcpp::from(values2) + .subscribe_on(loop) .take(n/2) .for_each( [](int p) { @@ -282,15 +283,15 @@ void RefCount(int n) }); auto values3 = rxcpp::from(rxcpp::Range(200)) - .subscribe_on(loop) .where(IsPrime) - .select([](int p){cout << endl << "producing: " << p << "-> "; return p;}) + .select([](int p) -> int {cout << endl << "producing: " << p << "-> "; return p;}) .take(n/2) .publish_last() - .ref_count(); // infinite (until overflow) stream of prime integers + .ref_count(); // last of n/2 prime integers cout << endl << "Subscription 1 - last published prime:"; rxcpp::from(values3) + .subscribe_on(loop) .for_each( [](int p) { cout << p << ", "; @@ -298,6 +299,7 @@ void RefCount(int n) cout << endl << "Subscription 2 - last published prime:" << endl; rxcpp::from(values3) + .subscribe_on(loop) .for_each( [](int p) { cout << p << ", "; -- GitLab From fad7930bbba99dc8b3ce773083b721856515b463 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 29 Aug 2013 00:59:25 -0700 Subject: [PATCH 060/782] workaround vc issue --- Rx/CPP/src/cpprx/rx-operators.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 94a3cd6..15abdd8 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -2157,9 +2157,9 @@ namespace rxcpp public: RefCountObservable(std::shared_ptr> source) : - ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable cancel, typename ProducerBase::SetSink setSink) -> Disposable + ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable&& cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::make_shared<_>(that, observer, std::move(cancel)); + auto sink = std::shared_ptr<_>(new _(that, observer, std::move(cancel))); setSink(sink->GetDisposable()); return sink->Run(); }), -- GitLab From b95c1c05ac4d1d2976fdf4ea9f8307eb6938861d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 29 Aug 2013 01:12:09 -0700 Subject: [PATCH 061/782] remove testbench.exe file --- Rx/CPP/testbench/testbench.exe | Bin 1731584 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 Rx/CPP/testbench/testbench.exe diff --git a/Rx/CPP/testbench/testbench.exe b/Rx/CPP/testbench/testbench.exe deleted file mode 100644 index ce8ef7ef51e160e1da5e1bd243ca203859ba278f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1731584 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

gm|)NzeYZ%k;~0B=&%8Jl3T87MbG^<0 zIvGGJ9L#6#bv+Z%>w6%uH}pDq|9)?;$N&HTUvRJa`yaZse@eiMvx5Ksce-xq_TA9w zI{|dC8RQV>>!6bW0wKqbyvSS)*U=I1VmCiX$DZ!cJ)NNq$6Wug_JWQNX0-)H7w9UQ zr5XSK{||W4q76EDe@?IOfw6&(bllWGOR!(r z!G7$`0r~Iu>c9WHL5FCr2n2;r&K+jZfo*Ic)dn}&7r2^m4^v{&cq45)_SQ#9^%@iHDDJW2zb#2HfqL;A}i1t z3>+Ze_WCY(@febRm_Sh?F2D|Q1UR}@^MlzSFTCJK-KDzVG8+T(iVfcn#%Et_Q~)2r z0ZTEE^+=?q7coeh06Sn-FgVQM>E%@jn2#&Hc(=l1e@eiMxon`=$DdwSw!n3C1iYwr z0_i|cFITP5(o2XYC_)hFWy>2Z>E*u#W_o%3jzD_(#e+yM=gh%=MNTi)t*Ghc79zbc zT!*KZqro8OVM{NowXviZH9p+wB?@fRj2BLj6O&=-W%CuV)4=KFIWIVkfTOD#!Um_8 z`>4A%3oc?wFO70kNH5PIX#(tktU!pvVCBoMATS?SdWqf)kNqhDFJ!wxv5!B!?A!#` z(Gl?CbreVkdU{!EftFrW)Ikw~NG~ne%9rzInCWHr8v^O&6c-}B%rgc16*;|lZ$?Qk zcdjGS%Y`fO^fEON zdXa{(!Re(QbrY$;SuE*AQHl!br45oM!0Cm{7veBjdWrG_^KqpY?ml?zPYHO@D?>QF zWcI>!bOgMJ{*5iYxSF7)mm^A`P(-8`6>RAx-w3mOiGD#Ky=1W=(u`>9d~*;`rs6n^zu=h3h5;bk|x0E<(3!3VX*X~P^BE5WhkEMLEH^59U+Rq527b_M-dg0Rt`xQC8RBu5| zFP9MM#o-)0y|8+NoQEyFyjH@JUeZ``ra5^20*syZlu z540XARR;BCUa&%z=Rk>p$b8uF4GH7MUdmc_XfS#dkPvD50Do-Fo60|PN$GMwF)ncL7CSTV?{lr zztKUg|3LR>^!iG?XjMb?pDJW|J=}j1FFsF!_;2?~sQ(V>A^Fb~d`UUTe@qDfNkIHJ zvk~FHxfihcj}hd*q?6zT$pBi+VTQc=TjGWLNt_*c==~ZmOdzi5;^5zQ5q#ppWnLE0 zT|6j<<-_~$#GcpRgj-|_DdEs3R%1bPru88ydctNN2@l6JK72j!n zYhL`rep=t>Ng%C|)B4J9fI)!0v$T!#nUI7k9`&PP9PDKcH(JKo=48hJFZo z@d-SG#nb8fqZ@pi1xMhE{g8cA-LNzJdVN2fP6!YY0-u$LAh7y12(f4dI?Ym+-l# z?j}6d5ZVWFy#(kM zK@1N_yjXGwdtjoJm(6c@K=y#oO9huSbs9$L73-6Z2rfSKk9lB<^}Dhg8PuduZRla=Vyi#zf^GFJf!sZ zhzjXNt^*N%pLS3letNYC^Mt5i-oF-vc}1rwci+Eh2=f;0rQE!{6$taFQ9jqrMwqt= zT%S``Ud=-)PlXOp;9tb}$P2F}5I6dA1imE2e5cJ|*Kg29h>o#Z)+-+FKZ9r}VVMzO}0J(kPfTeu_KHL7d>mSJe5{G~n zDRQ9E1<(X_>Vtq6&v-y%STDMLUv&E30nfmNY6QJ-K&ZJ9@Zu0y4d@2hPS-2osc~O{ zz!x$IH5US2%mb@A(;K=a2(*Xf#lJfsKlpUIo&e2^gYH&&bDNu?)Aa*n(m3@9`1&l1 zOQ2E)bn8xFcjyPubuJ%3*SUaZF@A>DR|7in9uwS6cFFB4hh@Y=?WExZH}YHkF)m;_dX9$s%`;O1Nic##KIg9xv4 zchSRZ&n?XG;iu0=IzK;P7(Yf;7zG@WN~hwZn@A;m-#FFWR`Uh1UaV zcv##Bc##BFgC1Uc5Na+2ys!hSL4?;la2<@2z9d0I%Bbn<#(AQ{%XS+$jKJZgxEag_ zhnMJPl<;EPOzrTxA_WhN2LUg_II)G-285a$0WXZeYS6>02chOdzzaUG8bo;IVT9Kn z3C!?XagONl;)UcvaCm*(hzPHz8&SgR+D2-J*AhwO@KWQz7G4bqH8%oYFoD&ehgS?j z&4qv$_t-(^Ai~QIBfNUVF~h6kEYab07m}vH;dO8WBD}V4Knbs98>k&#B@)Qt^^FbW zPxSIW0HNkaz>7;@HR$1`gHUrJ;Ke$y8bo;UVT4zV7-o2RoFO{A)@}la5jeait_QQh z`LT69N_ds6r*?R`h$DyBF;;BhrGQX#BjCj%up0F6`XdH6=R&}XIQ36oJ*C zhu0Z|nhOCh{J?4u;k6DUy#5GdhS!UeM2D9zBoBha%Wy3syj0hsgqPS_YKPYo5qMZU z2zZgkj4iwlAk^Flc;N(AgC1UU5Na+2ypRK{L4;QwMtGeO!VIq+Cx{L&Sx6oPhZo}- zM0kB&jS^nZR#Q8?wg@AKml+eb@S1>7b0gq|5LgX*c;z6}TnKpajuB)IBE0-C!fTEo zW_WcRCpx^|LedmCye_UngxAqkDB-nj6}7{wMF=^(*uefoFYgl&YHkF)c*Fn-3-s`^ zL8!S9@M0fW4I;ecFv2TG05iNIju9PRdm(8G99|1oBEoCxN|f+wTS@Kk3K2vOuWSEV z89H6j!^;4n=0?DaO<*iu z3Ri&H;QBFj1xk2@t)O;zsR$s4*Rp@u!ixc+=0?DaCa@ax@VdhfH|IjYi#V_vM0oAP z2rnK!%<%egnCS3|h2%kScsVXdgqP`Zl<-npPVMme!Uy-~gMb%hf3bzv1%#R#0WX5U zYS6=L4MNR@fERjTHHh%)!w9cCJec8i;tj*D$ zc)9(-7G4VwYHkF)Py(w#53d@8nhOCh{{04-g9xuUjPP2+jTv4u4iX(+e<5iK99|EX zAj0eF5|r>dwuIW@HH8N`yu`r%L@&Pz5Nd7&y!iAB6c*^=<%3XjA>hS1uo^^o>0yLd z4Hss3WgH+nyv{<>6ga##E=Gjc(#0s@HEl7q!z+awIlP|z1ce29csU@{fX2VTYS6<= z2B8Kt{smTp2(N#~(Z_RqI5ES^Vn5O0HFqgEjKJa5xCqP!m-nTMP{J#15w*k1gbO*m zw*9~sUIGX;pz$xT8uajb!wEMBH2wuvg9xv47~v(uff-&L`-l#&Tu2@ShgaZ2M0mL_ zLQD1&6E;Ix`)VgTQm#7^?yVUi9Hi=b*7( z5QdD8Q|6u-ya@N?EW_uXe>l?-$Soj@bv^+;{(r6rWD{imebG#iO=QiVz|DK-i!je< zA?4=XLz*9RT0*&b`%)0@+q8;u^WKFZ%oAEehIt&_@cVX?z_AXwZ?|m|$SfYv+7YyQ z9klpF(*KAP;uc?yz!%rZ(4WMI(66?cNc+*&U##^`c26F%Ws)MMIO@q%RHi>vI*acPOkkpR&)k}wL(^OK3xv-9M%<`S@Xay zgG>z_crklEuA&Q+J)!rLacCm#KfS@oz<@EO*4t_U-q#reUii)eU9QvH>+t{o|G*b+ z5K++O)4fwA{{R0U^uib}#MIlX0NQgokpr|Godd*d12aGT`~Uw%HJEt=#4G?a!Mjvb zIY6tZK&fl#m4E;LXED4`1~tuEbwC`(7st+WGX!L%^tLj99i@H?6dDqptxNuaH{Fs|AR6T)EyXlTWkLP{~rLEnp+z3@BjbasUS}V zy_miYv?d?4Q?(nsU$wJ!2E<^N-d=@&|NjR<^_YP5fZP!DA{nfw2PD#(12XqTAUN)M zzze({bo#b{rUXHIO1phqUX&{HFn}-5zR@`qv~Bg6>mT-R$OcxeCCm(+t{1vpFLbto zHkpEVr}lzaFXlgBV(4@|(d~Ppvo{8^kCw9=%zDAn!_3gx>Hu*jcW*Dqn=jt0fon9L z-d>PTUp#+J=(_r)PKc#vCwLYd*k22g9I)d0j{d=Y#G6y!|3Q(u4r z@WmGJl46O@Rt<=i{JpK9i0gDc(Ax`&%ue4Oy;DIE+!;Edw-prWovs^teLn~GhJFfq zF%7)RlLK-sIrxI{)-#|mgNCaNC={XTh|p{}q2xuO-6zyn@@%PkVvl& z$n+PkjG%IWr_*&scjyYp#%ZBru78BPeH&h6DuU9&f^OFZovjs+SQY8+1+iYpEdr&5 z8Qs1!I(tD|qK~=$5$y)EUQE6RN(-P10XwIHwp<@`{Ug@h3u3)k(FxM^qTBUFr|Xkr zu7AY4eV@E21{-y!+xJeVFK9YjqTBb%i*;Z_&UA;K=?pz`%=M3Cx9^b`Cntim@9B2k z)9DJ@8!grCyX8d-Sml~--!+}SOOCnzkv``7N2S|$$&1;SKohoexfp$cz_V$9}{e_zfIH9UQqV$D1gsa@! z3yRhk8W65hZ!ainUr0i@ije4i!3E(e^!9?{_r-5zuu<~8y`U(5@dm<`gGBR-yAZBy zZ!ajOUz~$*WqNx-QTbv&gv;LxjS$V+hE&aWt5rw^susun{b92P~ih5?BBhcmNgvmx%pffhTao?cs*2 zK4W7Dc%cvHi-P&`a6T)T&kyH+eagnred0ykOSqdvKsM@uEyy_ra+3f^Ko%@e02bf@ z3GjdgO27i3T>9eocaS$Kj=?;8{zyhEm+#EUS5o1TDdWCL5^aU2v*4?qH6zkx!*2P|+0B=7_*5C9ecm2WRD zg9Sp4!@{WRqtPGv7_K4Y0P~`}3k4y(|8KYi%gnb>TJ|V3= za(OLC4|03t;4dbI<|EkKBTuD3bN5loqhIN0_gH(gN1@ z$c}1|F0}T@W3W+Z?GZV!A!zLpOK@`rtv&MPD#$u4?Gf%%SlT1UK&rtl5ghH2rC(9n zBip3G2^H2JSq|aC+9NX{Tv&Ug6T*eHN2(xPSbHQJ!iBX*Vjx^td&C#Qg|$cQAY52` zL?6P1wMP`Bp*2KC!Vy@t!;=6j;+q~qWufg6qYt1e?8XsLod#}?D1rs0k?p_?U7WlKm=F-+#Ug)=O2&} z0~P>RR?c7*3Gg=3=U7-c+`J76m&b7aNihF1oWB#yKMd!u1RZa9;)M~yP2l#(qqm@7 z*#ou_+#b0I7B~PF0JldDfCY|#1;DlDda%F=xSQhPcDRD=^oR3J!F+o-Ulq*Phx0`t zZkh)v#0_2=hx&

=gS+)mM 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�n1PxA@t`^GNYFa#?sG31K;ssz2TH`dLwQ;+ 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℘Fb>lckCoIiNWVXO=9nfESzi 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\^{? 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 Date: Fri, 30 Aug 2013 23:24:10 -0700 Subject: [PATCH 062/782] fix for ScheduledObserver --- Rx/CPP/src/cpprx/rx-scheduler.hpp | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 2a3a5fc..ca72835 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -268,21 +268,36 @@ namespace rxcpp std::unique_lock guard(lock); auto local = this->shared_from_this(); queue.push(Action([=](){ - local->observer->OnNext(std::move(element));})); + std::unique_lock guard(lock); + auto o = local->observer; + guard.unlock(); + if (o){ + o->OnNext(std::move(element)); + }})); } virtual void OnCompleted() { std::unique_lock guard(lock); auto local = this->shared_from_this(); queue.push(Action([=](){ - local->observer->OnCompleted();})); + std::unique_lock guard(lock); + auto o = local->observer; + guard.unlock(); + if (o){ + o->OnCompleted(); + }})); } virtual void OnError(const std::exception_ptr& error) { std::unique_lock guard(lock); auto local = this->shared_from_this(); queue.push(Action([=](){ - local->observer->OnError(std::move(error));})); + std::unique_lock guard(lock); + auto o = local->observer; + guard.unlock(); + if (o){ + o->OnError(std::move(error)); + }})); } void EnsureActive() -- GitLab From 6a1fc44dcce3e71d780fd7976bacbee80e2b808c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 30 Aug 2013 23:34:19 -0700 Subject: [PATCH 063/782] Adds many new operators and some bug fixes - DeferOperation - ReactiveCommand and BindCommand - Producer and Sink helpers - Return - Throw - Using - ConnectForever - Scan --- Rx/CPP/src/cpprx/rx-operators.hpp | 373 ++++++++++++++++++++++++++++-- Rx/CPP/src/cpprx/rx-winrt.hpp | 320 ++++++++++++++++++++++++- Rx/CPP/src/cpprx/rx.hpp | 9 + 3 files changed, 679 insertions(+), 23 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 15abdd8..0589c09 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -789,29 +789,34 @@ namespace rxcpp return std::make_shared>(); } - template - auto ToAsync(Scheduler::shared scheduler, F && f) - -> std::shared_ptr> + template + std::function < std::shared_ptr < Observable> (A)> ToAsync(std::function f, Scheduler::shared scheduler = nullptr) { - typedef decltype(f()) Value; - auto result = CreateAsyncSubject(); - scheduler->Schedule([=]() -> Disposable + if (!scheduler) { - util::maybe value; - try - { - value.set(f()); - } - catch (...) + scheduler = std::make_shared(); + } + return [=](A a) -> std::shared_ptr < Observable> + { + auto result = CreateAsyncSubject(); + scheduler->Schedule([=](Scheduler::shared) -> Disposable { - result->OnError(std::current_exception()); + util::maybe value; + try + { + value.set(f(a)); + } + catch (...) + { + result->OnError(std::current_exception()); + return Disposable::Empty(); + } + result->OnNext(*value.get()); + result->OnCompleted(); return Disposable::Empty(); - } - result->OnNext(value.get()); - result->OnCompleted(); - return Disposable::Empty(); - }); - return result; + }); + return result; + }; } template @@ -859,6 +864,136 @@ namespace rxcpp } }; + + namespace detail + { + template + class ReturnObservable : public Producer, T> + { + typedef std::shared_ptr> Parent; + T value; + Scheduler::shared scheduler; + + class _ : public Sink<_, T> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + auto local = parent; + auto that = this->shared_from_this(); + return parent->scheduler->Schedule( + [=](Scheduler::shared) -> Disposable { + that->SinkBase::observer->OnNext(local->value); + that->SinkBase::observer->OnCompleted(); + that->SinkBase::Dispose(); + return Disposable::Empty(); + }); + } + }; + + typedef Producer, T> ProducerBase; + public: + + ReturnObservable(T value, Scheduler::shared scheduler) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + value(value) + { + if (!scheduler) + { + scheduler = std::make_shared(); + } + } + }; + } + template + const std::shared_ptr> Return( + T value, + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(value), std::move(scheduler)); + } + + namespace detail + { + template + class ThrowObservable : public Producer, T> + { + typedef ThrowObservable This; + typedef std::shared_ptr Parent; + + std::exception_ptr exception; + Scheduler::shared scheduler; + + class _ : public Sink<_, T> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + auto local = parent; + auto that = this->shared_from_this(); + return parent->scheduler->Schedule( + [=](Scheduler::shared) -> Disposable { + that->SinkBase::observer->OnError(local->exception); + that->SinkBase::Dispose(); + return Disposable::Empty(); + }); + } + }; + + typedef Producer ProducerBase; + public: + + ThrowObservable(std::exception_ptr exception, Scheduler::shared scheduler) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + exception(exception) + { + if (!scheduler) + { + scheduler = std::make_shared(); + } + } + }; + } + template + const std::shared_ptr> Throw( + std::exception_ptr exception, + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(exception), std::move(scheduler)); + } + template struct fix0_thunk { F f; @@ -1036,6 +1171,101 @@ namespace rxcpp }); } + namespace detail + { + template + class UsingObservable : public Producer, T> + { + typedef UsingObservable This; + typedef std::shared_ptr Parent; + typedef std::shared_ptr> Source; + + public: + typedef std::function ResourceFactory; + typedef std::function ObservableFactory; + + private: + ResourceFactory resourceFactory; + ObservableFactory observableFactory; + + class _ : public Sink<_, T>, public Observer + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + ComposableDisposable cd; + Source source; + auto disposable = Disposable::Empty(); + + try + { + auto resource = parent->resourceFactory(); + disposable = resource; + source = parent->observableFactory(resource); + } + catch (...) + { + cd.Add(Throw(std::current_exception())->Subscribe(this->shared_from_this())); + cd.Add(std::move(disposable)); + return cd; + } + + cd.Add(source->Subscribe(this->shared_from_this())); + cd.Add(std::move(disposable)); + return cd; + } + + virtual void OnNext(const T& t) + { + SinkBase::observer->OnNext(t); + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer ProducerBase; + public: + + UsingObservable(ResourceFactory resourceFactory, ObservableFactory observableFactory) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + resourceFactory(resourceFactory), + observableFactory(observableFactory) + { + } + }; + } + template + const std::shared_ptr> Using( + typename detail::UsingObservable::ResourceFactory resourceFactory, + typename detail::UsingObservable::ObservableFactory observableFactory + ) + { + return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); + } + ////////////////////////////////////////////////////////////////////// // // imperative functions @@ -1143,7 +1373,7 @@ namespace rxcpp const typename observable_item< typename std::result_of::type>::type&)>::type>> { - typedef typename std::result_of::type C; + typedef typename std::decay::type>::type C; typedef typename observable_item::type CI; typedef typename std::result_of::type U; @@ -2089,6 +2319,7 @@ namespace rxcpp auto multicastSubject = std::make_shared>(); return Multicast(source, multicastSubject); } + namespace detail { template @@ -2178,6 +2409,108 @@ namespace rxcpp return std::make_shared>(source); } + template + const std::shared_ptr> ConnectForever( + const std::shared_ptr>& source + ) + { + source->Connect(); + return observable(source); + } + + namespace detail + { + template + class ScanObservable : public Producer, A> + { + typedef ScanObservable This; + typedef std::shared_ptr Parent; + typedef std::shared_ptr> Source; + typedef std::shared_ptr> Destination; + + public: + typedef std::function Accumulator; + + private: + + Source source; + A seed; + Accumulator accumulator; + + class _ : public Sink<_, A>, public Observer + { + Parent parent; + util::maybe accumulation; + + public: + typedef Sink<_, A> SinkBase; + + _(Parent parent, Destination observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + virtual void OnNext(const T& t) + { + try + { + if (accumulation) + { + accumulation.set(parent->accumulator(*accumulation.get(), t)); + } + else + { + accumulation.set(parent->accumulator(parent->seed, t)); + } + } + catch (...) + { + SinkBase::observer->OnError(std::current_exception()); + SinkBase::Dispose(); + return; + } + SinkBase::observer->OnNext(*accumulation.get()); + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer ProducerBase; + public: + + ScanObservable(Source source, A seed, Accumulator accumulator) : + ProducerBase([this](Parent parent, std::shared_ptr < Observer < A >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(std::move(source)), + seed(std::move(seed)), + accumulator(std::move(accumulator)) + { + } + }; + } + template + const std::shared_ptr> Scan( + const std::shared_ptr>& source, + A seed, + typename detail::ScanObservable::Accumulator accumulator + ) + { + return std::make_shared>(std::move(source), std::move(seed), std::move(accumulator)); + } + template std::shared_ptr> Take( const std::shared_ptr>& source, diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp index 02d15da..9b3dca6 100644 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -14,6 +14,7 @@ namespace rxcpp { namespace winrt { namespace wf = Windows::Foundation; namespace wuicore = Windows::UI::Core; namespace wuixaml = Windows::UI::Xaml; + namespace wuictrls = Windows::UI::Xaml::Controls; template struct EventPattern @@ -23,9 +24,9 @@ namespace rxcpp { namespace winrt { eventargs(eventargs) {} - TSender Sender() { + TSender Sender() const { return sender;}; - TEventArgs EventArgs() { + TEventArgs EventArgs() const { return eventargs;}; private: @@ -288,7 +289,12 @@ namespace rxcpp { namespace winrt { { throw std::logic_error("No window current"); } - return std::make_shared(window->Dispatcher); + auto d = window->Dispatcher; + if (d == nullptr) + { + throw std::logic_error("No dispatcher on current window"); + } + return std::make_shared(d); } wuicore::CoreDispatcher^ Dispatcher() @@ -355,6 +361,314 @@ namespace rxcpp { namespace winrt { wuicore::CoreDispatcherPriority priority; }; + template + class ReactiveCommand : public Observable + { + typedef ReactiveCommand This; + + std::mutex flight_lock; + std::shared_ptr < Subject> inflight; + std::shared_ptr < Subject> exceptions; + std::shared_ptr> executed; + Scheduler::shared defaultScheduler; + bool allowsConcurrentExecution; + std::shared_ptr < Observable < bool >> isExecuting; + std::shared_ptr < Observable < bool >> canExecuteObservable; + + public: + typedef std::shared_ptr shared; + + ReactiveCommand(std::shared_ptr < Observable < bool >> canExecute = nullptr, bool allowsConcurrentExecution = false, Scheduler::shared scheduler = nullptr, bool initialCondition = true) : + inflight(std::make_shared < Subject < bool >> ()), + exceptions(std::make_shared < Subject >()), + executed(std::make_shared < Subject < T >> ()), + defaultScheduler(scheduler), + allowsConcurrentExecution(allowsConcurrentExecution) + { + if (!canExecute) + { + canExecute = Return(true); + } + if (!defaultScheduler) + { + defaultScheduler = std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()); + } + + isExecuting = observable(from(inflight) + .scan(0, [](int balanced, bool in) { + return in ? balanced + 1 : balanced - 1; }) + .select([](int balanced) { + return balanced > 0; }) + .publish(false) + .connect_forever() + .distinct_until_changed()); + + auto isBusy = allowsConcurrentExecution ? Return(false) : isExecuting; + auto canExecuteAndNotBusy = from(isBusy) + .combine_latest([](bool b, bool ce) + { + return ce && !b; + }, canExecute); + + auto canExecuteObs = from(canExecuteAndNotBusy) + .publish(initialCondition) + .ref_count(); + + canExecuteObservable = observable(from(canExecuteObs) + .distinct_until_changed() + .observe_on(defaultScheduler)); + } + + template + std::shared_ptr> RegisterAsync(std::function>(T)> f) + { + return observable(from(executed) + .select_many( + // select collection + [=](T t) -> std::shared_ptr> + { + return Using( + // resource factory + [=]() -> SerialDisposable + { + std::unique_lock guard(flight_lock); + inflight->OnNext(true); + SerialDisposable flight; + flight.Set(ScheduledDisposable( + defaultScheduler, + Disposable([=]() + { + std::unique_lock guard(flight_lock); + inflight->OnNext(false); + }))); + return flight; + }, + // observable factory + [=](SerialDisposable) -> std::shared_ptr> + { + return f(t); + }); + }) + .observe_on(defaultScheduler) + .publish() + .connect_forever()); + } + + template + std::shared_ptr> RegisterAsyncFunction(std::function < R(T)> f, Scheduler::shared scheduler = nullptr) + { + auto asyncFunc = ToAsync(f, scheduler); + return RegisterAsync(asyncFunc); + } + + bool AllowsConcurrentExecution() + { + return allowsConcurrentExecution; + } + + std::shared_ptr> ThrownExceptions() + { + return from(exceptions).observe_on(defaultScheduler); + } + + std::shared_ptr> IsExecuting() + { + return isExecuting; + } + + std::shared_ptr> CanExecuteObservable() + { + return canExecuteObservable; + } + + Disposable Subscribe(std::shared_ptr < Observer < T >> observer) + { + return from(executed) + .subscribe( + //on next + [=](const T& t){ + try + { + observer->OnNext(t); + } + catch (...) + { + exceptions->OnError(std::current_exception()); + } + }, + //on completed + [=](){ + try + { + observer->OnCompleted(); + } + catch (...) + { + exceptions->OnError(std::current_exception()); + } + }, + //on error + [=](std::exception_ptr e){ + try + { + observer->OnError(e); + } + catch (...) + { + exceptions->OnError(std::current_exception()); + } + }); + } + + void Execute(T value) + { + { + std::unique_lock guard(flight_lock); + inflight->OnNext(true); + } + executed->OnNext(value); + { + std::unique_lock guard(flight_lock); + inflight->OnNext(false); + } + } + }; + + template + std::shared_ptr> observable(std::shared_ptr < ReactiveCommand < T >> s){ return std::static_pointer_cast < Observable < T >> (s); } + + template + Disposable BindCommand(wuictrls::Button^ button, std::shared_ptr> command) + { + typedef rxrt::EventPattern RoutedEventPattern; + + ComposableDisposable cd; + + cd.Add(from(command->CanExecuteObservable()) + .subscribe( + [=](bool b) + { + button->IsEnabled = b; + })); + + auto click = rxrt::FromEventPattern( + [=](wuixaml::RoutedEventHandler^ h) + { + return button->Click += h; + }, + [=](wf::EventRegistrationToken t) + { + button->Click -= t; + }); + + cd.Add(from(click) + .subscribe([=](RoutedEventPattern ep) + { + command->Execute(ep); + })); + + return cd; + } + + template + struct OperationPattern + { + typedef decltype(((O)nullptr)->GetDeferral()) D; + + OperationPattern(O operation) : + operation(operation), + deferral(operation->GetDeferral()) + { + } + + O Operation() const { + return operation; + }; + D Deferral() const { + return deferral; + }; + + private: + O operation; + D deferral; + }; + + namespace detail + { + + template + auto DeferOperation(const std::shared_ptr < Observable < T >> &source, SOp sop, SOb sob, Scheduler::shared scheduler = nullptr) + -> decltype(sob(*(OperationPattern*)nullptr, *(T*) nullptr)) + { + typedef decltype(sob(*(OperationPattern*)nullptr, *(T*) nullptr)) ResultObservable; + typedef typename observable_item::type Result; + if (!scheduler) + { + scheduler = std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()); + } + return rx::CreateObservable( + [=](const std::shared_ptr < Observer < Result >> &observer) + { + return from(source) + .select_many( + //select observable + [=](T t) -> ResultObservable + { + // must take the deferral early while the event is still on the stack. + auto o = sop(t); + auto op = OperationPattern(o); + + return Using( + // resource factory + [=]() -> SerialDisposable + { + // return a disposable that will complete the operation + SerialDisposable scope; + scope.Set(ScheduledDisposable( + scheduler, + Disposable( + [=]() + { + op.Deferral()->Complete(); + }))); + return scope; + }, + // observable factory + [=](SerialDisposable) + { + return sob(op, t); + }); + }) + .observe_on(scheduler) + .subscribe( + //on next + [=](Result r) + { + observer->OnNext(r); + }, + //on completed + [=]() + { + observer->OnCompleted(); + }, + //on error + [=](std::exception_ptr e) + { + observer->OnError(e); + } + ); + }); + } + } + + struct defer_operation {}; + template + auto rxcpp_chain(defer_operation && , const std::shared_ptr < Observable < T >> &source, SOp sop, SOb sob, Scheduler::shared scheduler = nullptr) + -> decltype(detail::DeferOperation(source, sop, sob, scheduler)) + { + return detail::DeferOperation(source, sop, sob, scheduler); + } + } } #endif diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index efecd89..b3029e5 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -114,6 +114,10 @@ namespace detail { -> decltype(from(RefCount(obj))) { return from(RefCount(obj)); } + auto connect_forever() + -> decltype(from(ConnectForever(obj))) { + return from(ConnectForever(obj)); + } }; template @@ -270,6 +274,11 @@ namespace detail { -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { return from(GroupBy(obj, keySelector, valueSelector, less)); } + template + auto scan(Seed seed, A accumulator) + -> decltype(from(Scan(obj, seed, accumulator))) { + return from(Scan(obj, seed, accumulator)); + } template auto take(Integral n) -> decltype(from(Take(obj, n))) { -- GitLab From 9d9699eb0ea79bbb33917e9071f219ad0ba4cfce Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 31 Aug 2013 11:25:55 -0700 Subject: [PATCH 064/782] make OperationPattern Disposable --- Rx/CPP/src/cpprx/rx-winrt.hpp | 44 +++++++++++++++++++++++------------ 1 file changed, 29 insertions(+), 15 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp index 9b3dca6..b60d205 100644 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -588,11 +588,34 @@ namespace rxcpp { namespace winrt { return deferral; }; + void Dispose() + { + deferral->Complete(); + } + + operator Disposable() const + { + // make sure to capture state and not 'this'. + // usage means that 'this' will usualy be destructed + // immediately + auto local = deferral; + return Disposable([local]{ + local->Complete(); + }); + } + private: O operation; D deferral; }; + template + OperationPattern make_operation_pattern(O o) + { + return OperationPattern(std::move(o)); + } + + namespace detail { @@ -615,26 +638,17 @@ namespace rxcpp { namespace winrt { [=](T t) -> ResultObservable { // must take the deferral early while the event is still on the stack. - auto o = sop(t); - auto op = OperationPattern(o); + auto op = make_operation_pattern(sop(t)); + typedef decltype(op) OP; - return Using( + return Using( // resource factory - [=]() -> SerialDisposable + [=]() -> OP { - // return a disposable that will complete the operation - SerialDisposable scope; - scope.Set(ScheduledDisposable( - scheduler, - Disposable( - [=]() - { - op.Deferral()->Complete(); - }))); - return scope; + return op; }, // observable factory - [=](SerialDisposable) + [sob, t](OP op) { return sob(op, t); }); -- GitLab From 623e9fe655c6706b0a1ef64920defd08d941025e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 31 Aug 2013 12:38:03 -0700 Subject: [PATCH 065/782] fix FromAsyncPattern to only require the function arg types to be provided --- Rx/CPP/src/cpprx/rx-winrt.hpp | 35 ++++------------------------------- 1 file changed, 4 insertions(+), 31 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp index b60d205..cd123e3 100644 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -160,39 +160,12 @@ namespace rxcpp { namespace winrt { }); } - template - auto FromAsyncPattern(F&& start) - -> std::function < std::shared_ptr < Observable< decltype(start()->GetResults()) >> ()> + template + auto FromAsyncPattern(F&& start) + -> std::function < std::shared_ptr < Observable< decltype(start((*(T*)nullptr)...)->GetResults()) >> (const T&...)> { - return [=]() - { - typedef decltype(start()->GetResults()) Result; - auto subject = CreateAsyncSubject(); - auto o = start(); - typedef typename detail::remove_ref< decltype(o->Completed)>::type Handler; - typedef decltype(detail::operation_interface(o)) Interface; - o->Completed = ref new Handler([=](Interface io, wf::AsyncStatus) - { - util::maybe value; - try - { - value.set(io->GetResults()); - } - catch (...) - { - subject->OnError(std::current_exception()); - return; - } - subject->OnNext(*value.get()); - subject->OnCompleted(); - }); - return observable(subject); - }; - } + typedef decltype(start((*(T*)nullptr)...)->GetResults()) Result; - template - std::function < std::shared_ptr < Observable> (const T&...)> FromAsyncPattern(std::function start) - { return [=](const T&... t) { auto subject = CreateAsyncSubject(); -- GitLab From be6c6fcaae53219b940f2616e4bf54a1d82638af Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Sep 2013 08:23:19 -0700 Subject: [PATCH 066/782] Improve ToAsync and Using usage --- Rx/CPP/src/cpprx/rx-operators.hpp | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 0589c09..3816f2f 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -789,14 +789,17 @@ namespace rxcpp return std::make_shared>(); } - template - std::function < std::shared_ptr < Observable> (A)> ToAsync(std::function f, Scheduler::shared scheduler = nullptr) +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto ToAsync(F f, Scheduler::shared scheduler = nullptr) + ->std::function < std::shared_ptr < Observable< decltype(f((*(A*)nullptr)...)) >> (const A&...)> { + typedef decltype(f((*(A*) nullptr)...)) R; if (!scheduler) { scheduler = std::make_shared(); } - return [=](A a) -> std::shared_ptr < Observable> + return [=](const A&... a) -> std::shared_ptr < Observable> { auto result = CreateAsyncSubject(); scheduler->Schedule([=](Scheduler::shared) -> Disposable @@ -804,7 +807,7 @@ namespace rxcpp util::maybe value; try { - value.set(f(a)); + value.set(f(a...)); } catch (...) { @@ -818,6 +821,7 @@ namespace rxcpp return result; }; } +#endif template class ConnectableSubject : @@ -1257,12 +1261,15 @@ namespace rxcpp } }; } - template - const std::shared_ptr> Using( - typename detail::UsingObservable::ResourceFactory resourceFactory, - typename detail::UsingObservable::ObservableFactory observableFactory + template + auto Using( + RF resourceFactory, + OF observableFactory ) + -> decltype(observableFactory(resourceFactory())) { + typedef typename observable_item::type T; + typedef decltype(resourceFactory()) R; return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); } -- GitLab From 2d24c46acd3c5376d6e8e7a5bad1ccfc73a86464 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Sep 2013 08:25:45 -0700 Subject: [PATCH 067/782] ReactiveCommand fixes ensure that inflight is observed on the defaultScheduler so that IsExecuting is always on the UI thread. Improve Register function usage. --- Rx/CPP/src/cpprx/rx-winrt.hpp | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp index cd123e3..ab320f5 100644 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -362,12 +362,14 @@ namespace rxcpp { namespace winrt { { canExecute = Return(true); } + if (!defaultScheduler) { defaultScheduler = std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()); } isExecuting = observable(from(inflight) + .observe_on(defaultScheduler) .scan(0, [](int balanced, bool in) { return in ? balanced + 1 : balanced - 1; }) .select([](int balanced) { @@ -392,20 +394,21 @@ namespace rxcpp { namespace winrt { .observe_on(defaultScheduler)); } - template - std::shared_ptr> RegisterAsync(std::function>(T)> f) + template + auto RegisterAsync(F f) + -> std::shared_ptr> { return observable(from(executed) .select_many( // select collection - [=](T t) -> std::shared_ptr> + [=](T t) { - return Using( + std::unique_lock guard(flight_lock); + inflight->OnNext(true); + return Using( // resource factory [=]() -> SerialDisposable { - std::unique_lock guard(flight_lock); - inflight->OnNext(true); SerialDisposable flight; flight.Set(ScheduledDisposable( defaultScheduler, @@ -417,7 +420,7 @@ namespace rxcpp { namespace winrt { return flight; }, // observable factory - [=](SerialDisposable) -> std::shared_ptr> + [=](SerialDisposable) { return f(t); }); @@ -427,11 +430,12 @@ namespace rxcpp { namespace winrt { .connect_forever()); } - template - std::shared_ptr> RegisterAsyncFunction(std::function < R(T)> f, Scheduler::shared scheduler = nullptr) + template + auto RegisterAsyncFunction(F f, Scheduler::shared scheduler = nullptr) + -> std::shared_ptr> { - auto asyncFunc = ToAsync(f, scheduler); - return RegisterAsync(asyncFunc); + auto asyncFunc = ToAsync(f, scheduler); + return RegisterAsync(asyncFunc); } bool AllowsConcurrentExecution() @@ -614,9 +618,9 @@ namespace rxcpp { namespace winrt { auto op = make_operation_pattern(sop(t)); typedef decltype(op) OP; - return Using( + return Using( // resource factory - [=]() -> OP + [=]() { return op; }, -- GitLab From ef7ece0925a673237f5aabc8171111c064da1479 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Sep 2013 13:19:48 -0700 Subject: [PATCH 068/782] update _MSC_VER checks for VC2013 --- Rx/CPP/src/cpprx/rx-includes.hpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index 283ab98..d8dc7c1 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -32,7 +32,10 @@ #if _MSC_VER > 1600 #define RXCPP_USE_RVALUEREF 1 -#define RXCPP_USE_VARIADIC_TEMPLATES 0 +#endif + +#if _MSC_VER >= 1800 +#define RXCPP_USE_VARIADIC_TEMPLATES 1 #endif #if _CPPRTTI -- GitLab From 006f1aa7d5f94709a799735cc5be43219483f4f9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Sep 2013 13:20:22 -0700 Subject: [PATCH 069/782] pass arg pack to lambda using tuple --- Rx/CPP/src/cpprx/rx-operators.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 3816f2f..77de860 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -801,13 +801,14 @@ namespace rxcpp } return [=](const A&... a) -> std::shared_ptr < Observable> { + auto args = std::make_tuple(a...); auto result = CreateAsyncSubject(); scheduler->Schedule([=](Scheduler::shared) -> Disposable { util::maybe value; try { - value.set(f(a...)); + value.set(util::tuple_dispatch(f, args)); } catch (...) { -- GitLab From c94643820b9e7c29ed1b7720e7baa7a74bb4ef06 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Sep 2013 13:20:55 -0700 Subject: [PATCH 070/782] fix RegisterAsync return type --- Rx/CPP/src/cpprx/rx-winrt.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp index ab320f5..2e743b9 100644 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -396,7 +396,7 @@ namespace rxcpp { namespace winrt { template auto RegisterAsync(F f) - -> std::shared_ptr> + -> decltype(f(*(T*) nullptr)) { return observable(from(executed) .select_many( -- GitLab From 2840ee1831356650da078eb7a81d5cf7264cc25a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Sep 2013 13:21:51 -0700 Subject: [PATCH 071/782] disambiguate combine_latest --- Rx/CPP/src/cpprx/rx.hpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index b3029e5..f876922 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -202,13 +202,14 @@ namespace detail { #if RXCPP_USE_VARIADIC_TEMPLATES template auto combine_latest(S selector, const CombineLSource&... source) - -> decltype(from(CombineLatest(selector, obj, observable(source)...))) { + -> typename std::enable_if::value, decltype(from(CombineLatest(selector, obj, observable(source)...)))>::type { return from(CombineLatest(selector, obj, observable(source)...)); } - template - auto combine_latest(const CombineL1Source&... source) - -> decltype(from(CombineLatest(util::as_tuple(), obj, observable(source)...))) { - return from(CombineLatest(util::as_tuple(), obj, observable(source)...)); + template + auto combine_latest(const CombineL1Source& source, const CombineL1SourceN&... sourcen) + -> typename std::enable_if < is_observable::value, + decltype(from(CombineLatest(util::as_tuple(), obj, observable(source), observable(sourcen)...)))>::type { + return from(CombineLatest(util::as_tuple(), obj, observable(source), observable(sourcen)...)); } #else template -- GitLab From cfbe76b18869ae37e82ffd0917b09b11ebb638f4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Sep 2013 13:31:50 -0700 Subject: [PATCH 072/782] add is_observable for Binder --- Rx/CPP/src/cpprx/rx.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index f876922..54ae133 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -19,6 +19,9 @@ namespace detail { struct observable_item> {typedef typename rxcpp::observable_item::type type;}; } + template + struct is_observable < Binder > {static const bool value = true; }; + template class BinderBase { -- GitLab From d619cb5dc57d3cee876fd39302325640bbcf8dc4 Mon Sep 17 00:00:00 2001 From: Donna Malayeri Date: Wed, 4 Sep 2013 14:49:19 -0700 Subject: [PATCH 073/782] Add readme in html format, to be converted to markdown --- Readme.html | 303 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 303 insertions(+) create mode 100644 Readme.html diff --git a/Readme.html b/Readme.html new file mode 100644 index 0000000..0ffeade --- /dev/null +++ b/Readme.html @@ -0,0 +1,303 @@ +

Reactive Extensions

+ +

Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators.

+

Data sequences can take many forms, such as a stream of data from a file or web service, web services requests, system notifications, or a series of events such as user input.

+

Reactive Extensions represents all these data sequences as observable sequences. An application can subscribe to these observable sequences to receive asynchronous notifications as new data arrives. The Rx library is available for application development in C++, .NET, Ruby, Python, Silverlight, Windows Phone 7 and JavaScript. For more information on these different platforms, see Differences Between Versions of Rx topic.

+ +

Pulling vs. Pushing Data

+

In interactive programming, the application actively polls a data source for more information by pulling data from a sequence that represents the source. The iterator allows us to get the current item by returning the current property, and determines whether there are more items to iterate (by calling some on_next method).

+

The application is active in the data retrieval process, controlling the pace of the retrieval by calling on_next at its own convenience. This pattern is synchronous, which means that the application might be blocked while polling the data source. Such pulling pattern is similar to visiting your library and checking out a book. After you are done with the book, you pay another visit to check out another one.

+

On the other hand, in reactive programming, the application is offered more information by subscribing to a data stream (called observable sequence in Rx), and any update is handed to it from the source. The application is passive in the data retrieval process: apart from subscribing to the observable source, it does not actively poll the source, but merely reacts to the data being pushed to it. When the stream has no more data to offer, or when it errs, the source will send a notice to the subscriber. In this way, the application will not be blocked by waiting for the source to update.

+

This is the push pattern employed by Reactive Extensions. It is similar to joining a book club in which you register your interest in a particular genre, and books that match your interest are automatically sent to you as they are published. You do not need to stand in line to acquire something that you want. Employing a push pattern is helpful in many scenarios, especially in a UI-heavy environment in which the UI thread cannot be blocked while the application is waiting for some events. In summary, by using Rx, you can make your application more responsive.

+

The push model implemented by Rx is represented by the observable pattern of Rx.Observable/Observer. The Rx.Observable will notify all the observers automatically of any state changes. To register an interest through a subscription, you use the subscribe method of Rx.Observable, which takes on an Observer and returns a disposable. This gives you the ability to track and dispose of the subscription. In addition, Rxs LINQ implementation over observable sequences allows developers to compose complex event processing queries over push-based sequences such as events, APM-based (AsyncResult) computations, Task-based computations, and asynchronous workflows. For more information on the Observable/Observer classes, see Exploring The Major Classes in Rx. For tutorials on using the different features in Rx, see Using Rx.

+ +

Getting Started with Rx

+

This section describes in general what Reactive Extensions (Rx) is, and how it can benefit programmers who are creating asynchronous applications.

+ +

In This Section

+

1. When Will You Use Rx
+2. Installing Rx
+3. Differences Between Versions of Rx

+ +

Related Sections

+

Using Rx
+Reactive Extensions on MSDN Developer Center

+ +

When Will You Use Rx

+

This topic describes the advantage of using Rx for users who are currently using the .NET event model for asynchronous programming.

+ +

Advantages of using Rx

+

Whether you are authoring a traditional desktop or web-based application, you have to deal with asynchronous programming from time to time. Desktop applications have I/O or UI threads that might take a long time to complete and potentially block all other active threads. However, a user of the modern asynchronous programming model has to manage exceptions and cancellation of events manually. To compose or filter events, he has to write custom code that is hard to decipher and maintain.

+

In addition, if your application interacts with multiple sources of data, the conventional way to manage all of these interactions is to implement separate methods as event handlers for each of these data streams. For example, as soon as a user types a character, a keydown event is pushed to your keydown event handler method. Inside this keydown event handler, you have to provide code to react to this event, or to coordinate between all of the different data streams and process this data into a useable form.

+

Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer class. The Observable class maintains a list of dependent Observer threads and notifies them automatically of any state changes. You can query observable sequences using standard LINQ query operators implemented by the Rx.Observable type. Thus you can filter, aggregate, and compose on multiple events easily by using these LINQ operators. Cancellation and exceptions can also be handled gracefully by using extension methods provided by Rx.

+

The following example shows how easy it is to implement an observable in C++.

+ +//Declare an observable
+auto values1 = rxcpp::Range(1, 10);
+ rxcpp::from(values1)
+ .for_each(
+ [](int p) {
+ cout << p << endl;
+ }); + +

You can also use schedulers to control when the subscription starts, and when notifications are pushed to subscribers. For more information on this, see Using Schedulers for Concurrency Control.

+ +

Filtering

+

One drawback of the C++ event model is that your event handler is always called every time an event is raised, and events arrive exactly as they were sent out by the source. To filter out events that you are not interested in, or transform data before your handler is called, you have to add custom filter logic to your handler.

+

Take an application that detects mouse-down as an example. In the current event programming model, the application can react to the event raised by displaying a message. In Rx, such mouse-down events are treated as a stream of information about clicks. Whenever you click the mouse, information (e.g., cursor position) about this click appears in a stream, ready to be processed. In this paradigm, events (or event streams) are very similar to lists or other collections. This means that we can use techniques for working with collections to process events. For example, you can filter out those clicks that appear outside a specific area, and only display a message when the user clicks inside an area. Or you can wait a specific period of time, and inform the user the number of valid clicks during this period. Similarly, you can capture a stream of stock ticks and only respond to those ticks that have changed for a specific range during a particular time window. All these can be done easily by using LINQ-query style operators provided by Rx.

+

In this way, a function can take an event, process it, and then pass out the processed stream to an application. This gives you flexibility that is not available in the current programming model. Moreover, as Rx is performing all the plumbing work at the background for filtering, synchronizing, and transforming the data, your handler can just react to the data it receives and do something with it. This results in cleaner code that is easier to read and maintain. For more information on filtering, see Querying Observable Collections using LINQ Operators.

+ +

Manipulating Events

+

Rx represents events as a collection of objects: e.g., a OnMouseMove event contains a collection of Point values. Due to the first-class object nature of observables, they can be passed around as function parameters and returns, or stored in a variable.

+ +

Installing Rx

+

This topic describes where you can download the Reactive Extensions (Rx) SDK.

+ +

To download Rx

+

Reactive Extensions is available for different platforms such as C++, Javascript, .NET Framework 3.5, 4.0, 4.5, Silverlight 3 and 4, as well as Windows Phone 7 & 8. You can download the libraries, as well as learn about their prerequisites at the Rx MSDN Developer Center.

+ +

Differences Between Versions of Rx

+

The following topic describes the various platforms for which you can develop solutions using Reactive Extensions.

+

To get the latest release of Rx, as well as learn about its prerequisites, please visit the Rx MSDN Developer Center.

+ +

C++

+

The Reactive Extensions for C++ (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in C++.

+ +

Javascript

+

Rx for Javascript (RxJS) allows you to use LINQ operators in JavaScript. It provides easy-to-use conversions from existing DOM, XmlHttpRequest (AJAX), and jQuery events to push-based observable collections, allowing users to seamlessly integrate Rx into their existing JavaScript-based websites.

+

RxJS brings similar capabilities to client script and integrates with jQuery events (Rx.Observable.FromJQueryEvent). It also supports Script#.

+ +

Ruby

+

Rx for Ruby (Rx.rb) allows you to use Linq operators to create push-based observable collections in Ruby.

+ +

Python

+

RX for Python (Rx.py) allows you to use Linq operators in Python. Rx.py allows you to implement push-based observable collections, allowing users to seamlessly integrate Rx into their existing Python applications.

+ +

.NET Framework

+

The core Rx interfaces, IObservable and IObserver, ship as part of .NET Framework 4. If you are running on .NET Framework 3.5 SP1, or if you want to take advantage of the LINQ operators implemented in Observable type, as well as many other features such as schedulers, you can download the Rx header-only library in the Rx MSDN Developer Center.

+ +

Silverlight

+

Silverlight disallows you from making cross-threading calls, thus you cannot use a background thread to update the UI. Instead of writing verbose code using the Dispatcher.BeginInvoke call to explicitly execute code on the main UI thread, you can use the factory Observable.Start method provided by the Rx header-only library to invoke an action asynchronously. Cross-threading is taken care of transparently by Rx under the hood.

+

You can also use the various Observable operator overloads that take in a Scheduler, and specify the System.Reactive.Concurrency.DispatcherScheduler to be used.

+ +

Windows Phone

+

Windows Phone 7 ships with a version of the Reactive Extensions baked into the ROM of the device. For more information, see Reactive Extensions for .NET Overview for Windows Phone. Documentation for this version of the Reactive Extensions can be found in Windows Phone API library at Microsoft.Phone.Reactive Namespace.

+

The Rx MSDN Developer Center also contains an updated version of Rx for WP7, which has new definitions in the System.Reactive.Linq namespace. Note that the new APIs will not clash with the library built in to the phone (nor do they replace the version in the ROM). For more information on the differences of these 2 versions, see this Rx team blog post.

+

Rx is available for Windows Phone 8 as well as Windows Phone 7. A .NET portable library is available using Nuget that is useful for developing libraries that work on Windows Phone, Windows Store apps, and in classic Windows desktop or server applications.

+ +

Using Rx

+

This section includes topics that explain how you use Rx to create and subscribe to sequences, bridge existing events and existing asynchronous patterns, as well as using schedulers. It also describes more advanced tasks such as implementing your own operators.

+ +

In This Section

+

1. Exploring The Major Interfaces in Rx
+2. Creating and Querying Event Streams
+3. Subjects
+6. Implementing your own operators for IObservable
+7. Using Observable Providers

+ +

Exploring The Major Interfaces in Rx

+

This topic describes the major Reactive Extensions (Rx) interfaces used to represent observable sequences and subscribe to them.

+ +

Observable/Observer

+

Rx exposes asynchronous and event-based data sources as push-based, observable sequences. This Observable class represents a data source that can be observed, meaning that it can send data to anyone who is interested. It maintains a list of dependent Observer implementations representing such interested listeners, and notifies them automatically of any state changes.

+

As described in What is Rx, the other half of the push model is represented by the Observer class, which represents an observer who registers an interest through a subscription. Items are subsequently handed to the observer from the observable sequence to which it subscribes.

+

In order to receive notifications from an observable collection, you use the subscribe method of Observable to hand it an Observer object. In return for this observer, the subscribe method returns a disposable object that acts as a handle for the subscription. This allows you to clean up the subscription after you are done. Calling dispose on this object detaches the observer from the source so that notifications are no longer delivered. As you can infer, in Rx you do not need to explicitly unsubscribe from an event.

+

Observers support three publication events, reflected by the interfaces methods. OnNext can be called zero or more times, when the observable data source has data available. For example, an observable data source used for mouse move events can send out a Point object every time the mouse has moved. The other two methods are used to indicate completion or errors.

+

The following lists the Observable/Observer definitions.

+ +namespace rxcpp {
+ template
+ struct Observer
+ {
+ virtual void OnNext(const T&) {};
+ virtual void OnCompleted() {};
+ virtual void OnError(const std::exception_ptr&) {};

+ + virtual ~Observer() {}
+ };
+ + template
+ struct Observable
+ {
+ virtual Disposable Subscribe(std::shared_ptr> observer) = 0;
+ virtual ~Observable() {}
+ };
+} + +

Note that the OnError event returns an exception_ptr type. The example above shows passing the error to a handler function.

+

You can treat the observable sequence (such as a sequence of mouse-over events) as if it were a normal collection. Thus you can write LINQ queries over the collection to do things like filtering, grouping, composing, etc. To make observable sequences more useful, the Rx header-only library provides many factory LINQ operators so that you do not need to implement any of these on your own. This will be covered in the Querying Observable Collections using LINQ Operators topic.

+ +

See Also

+Creating and Subscribing to Simple Observable Sequences +Querying Observable Collections using LINQ Operators + +

Creating and Querying Observable Sequences

+

This section describes how you can create and subscribe to an observable sequence, convert an existing C++ event into a sequence and query it.

+ +

In This Section

+

Creating and Subscribing to Simple Observable Sequences
+Querying Observable Collections using LINQ Operators

+ +

Creating and Subscribing to Simple Observable Sequences

+

You do not need to implement the Observable interface manually to create an observable sequences. Similarly, you do not need to implement Observer either to subscribe to a sequence. By installing the Reactive Extension header-only library, you can take advantage of the Observable type which provides many LINQ operators for you to create a simple sequence with zero, one or more elements. In addition, Rx provides Subscribe methods that take various combinations of OnNext, OnError and OnCompleted handlers in terms of delegates.

+ +

Creating and subscribing to a simple sequence

+

The following sample uses the range operator of the Observable type to create a simple observable collection of numbers. The observer subscribes to this collection using the Subscribe method of the Observable class, and provides actions that are delegates which handle OnNext, OnCompleted and OnError.

+

The range operator has several overloads. In our example, it creates a sequence of integers that starts with x and produces y sequential numbers afterwards.

+

As soon as the subscription happens, the values are sent to the observer. The OnNext delegate then prints out the values.

+ +auto values1 = rxcpp::Range(1, 10);
+ rxcpp::from(values1)
+ .for_each(
+ [](int p) {
+ cout << p << endl;
+ }); + +

When an observer subscribes to an observable sequence, the thread calling the subscribe method can be different from the thread in which the sequence runs till completion. Therefore, the subscribe call is asynchronous in that the caller is not blocked until the observation of the sequence completes. This will be covered in more details in the Using Schedulers topic.

+

Notice that the subscribe method returns a Disposable, so that you can unsubscribe to a sequence and dispose of it easily. When you invoke the Dispose method on the observable sequence, the observer will stop listening to the observable for data. Normally, you do not need to explicitly call Dispose unless you need to unsubscribe early, or when the source observable sequence has a longer life span than the observer. Subscriptions in Rx are designed for fire-and-forget scenarios without the usage of a finalizer. When the Disposable instance is collected by the garbage collector, Rx does not automatically dispose of the subscription. However, note that the default behavior of the Observable operators is to dispose of the subscription as soon as possible (i.e, when an OnCompleted or OnError messages is published).

+

In addition to creating an observable sequence from scratch, you can convert existing enumerators, C++ events and asynchronous patterns into observable sequences. The other topics in this section will show you how to do this.

+

Notice that this topic only shows you a few operators that can create an observable sequence from scratch. To learn more about other LINQ operators, see Query Observable Collections using LINQ Operators.

+ +

Converting an Enumerable Collection to an Observable Sequence

+

Using the Iterate operator, you can convert an array colection to an observable sequence and subscribe to it.

+ + std::array< int, 3 > a={1, 2, 3};
+ auto values1 = rxcpp::Iterate(a);

+ + rxcpp::from(values1)
+ .for_each(
+ [](int p) {
+ cout << p << endl;
+ }); + + +

See Also

+Query Observable Collections using LINQ Operators + +

Querying Observable Sequences using LINQ Operators

+

We have converted existing C++ events into observable sequences to subscribe to them. In this topic, we will look at the first-class nature of observable sequences as Observable objects, in which generic LINQ operators are supplied by the Rx header-only library to manipulate these objects. Most operators take an observable sequence and perform some logic on it and output another observable sequence. In addition, as you can see from our code samples, you can even chain multiple operators on a source sequence to tweak the resulting sequence to your exact requirement.

+ +

Using Different Operators

+

We have already used the Create and Generate operators in previous topics to create and return simple sequences. In this topic, we will use other LINQ operators of the Observable type so that you can filter, group and transform data. Such operators take observable sequence(s) as input, and produce observable sequence(s) as output.

+ +

Combining different sequences

+

In this section, we will examine some of the operators that combine various observable sequences into a single observable sequence. Notice that data are not transformed when we combine sequences.

+

In the following sample, we use the concat operator to combine two sequences into a single sequence and subscribe to it.

+ +auto input1 = std::make_shared<rxcpp::EventLoopScheduler>();
+ auto input2 = std::make_shared<rxcpp::EventLoopScheduler>();
+ auto output = std::make_shared<rxcpp::EventLoopScheduler>();

+ + auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers
+ auto s1 = rxcpp::from(values1)
+ .subscribe_on(input1)
+ .select([](int prime) -> std::tuple<const char *, int> { return std::make_tuple("1:", prime);})
+ .take(3);

+ + auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers
+ auto s2 = rxcpp::from(values2)
+ .subscribe_on(input2)
+ .select([](int prime) -> std::tuple<const char *, int> { return std::make_tuple("2:", prime);})
+ .take(3);

+ + + + rxcpp::from(s1)
+ .concat(s2)
+ .observe_on(output)
+ .for_each(rxcpp::MakeTupleDispatch(
+ [](const char* s, int p) {
+ cout << p << endl;
+ })); + +

Notice that the resultant sequence is 1,2,3,1,2,3. This is because when you use the concat operator, the 2nd sequence (source2) will not be active until after the 1st sequence (source1) has finished pushing all its values. It is only after source1 has completed, then source2 will start to push values to the resultant sequence. The subscriber will then get all the values from the resultant sequence.

+

Compare this with the merge operator. If you run the following sample code, you will get 1,1,2,2,3,3. This is because the two sequences are active at the same time and values are pushed out as they occur in the sources. The resultant sequence only completes when the last source sequence has finished pushing values.

+

Notice that for Merge to work, all the source observable sequences need to be of the same type of Observable. The resultant sequence will be of the type Observable. If source1 produces an OnError in the middle of the sequence, then the resultant sequence will complete immediately.

+ +auto input1 = std::make_shared<rxcpp::EventLoopScheduler>();
+ auto input2 = std::make_shared<rxcpp::EventLoopScheduler>();
+ auto output = std::make_shared<rxcpp::EventLoopScheduler>();

+ + auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers
+ auto s1 = rxcpp::from(values1)
+ .subscribe_on(input1)
+ .select([](int data) -> std::tuple<const char *, int> { return std::make_tuple("1: ", data);});

+ + auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers
+ rxcpp::from(values2)
+ .subscribe_on(input1)
+ .select([](int data) -> std::tuple<const char *, int> { return std::make_tuple("2: ", data);})
+ .merge(s1)
+ .take(6)
+ .observe_on(output)
+ .for_each(rxcpp::MakeTupleDispatch(
+ [](const char* s, int p) {
+ cout << s << p << endl;
+ })); + +

Notice that for these combination operators to work, all the observable sequences need to be of the same type.

+ +

Subjects

+

This section describes the Subject type implemented by Reactive Extensions. It also describes various implementations of Subject which serves different purposes.

+

In This Section

+

1. Using Subjects

+ +

Using Subjects

+

The Subject type implements both Observable and Observer, in the sense that it is both an observer and an observable. You can use a subject to subscribe all the observers, and then subscribe the subject to a backend data source. In this way, the subject can act as a proxy for a group of subscribers and a source. You can use subjects to implement a custom observable with caching, buffering and time shifting. In addition, you can use subjects to broadcast data to multiple subscribers.

+

By default, subjects do not perform any synchronization across threads. They do not take a scheduler but rather assume that all serialization and grammatical correctness are handled by the caller of the subject. A subject simply broadcasts to all subscribed observers in the thread-safe list of subscribers. Doing so has the advantage of reducing overhead and improving performance. If, however, you want to synchronize outgoing calls to observers using a scheduler, you can use the Synchronize method to do so.

+ +

Different types of Subjects

+

The Subject type in the Rx library is a basic implementation of the Subject interface (you can also implement the Subject interface to create your own subject types). There are other implementations of Subject that offer different functionalities. All of these types store some (or all of) values pushed to them via OnNext, and broadcast it back to its observers. This means that if you subscribe to any of these more than once (i.e. subscribe -> unsubscribe -> subscribe again), you will see at least one of the same value again.

+ +

Scheduling and Concurrency

+

This section describes how you can use a scheduler to control when to start a sequence or subscribe to an event.

+ +

Scheduler Types

+

The various Scheduler types provided by Rx are:

+

ImmediateScheduler: Default scheduler, pushes notifications as they are recieved.

+

EventLoopScheduler: Used when creating a separate thread for Rx sequences.

+ +

Using Schedulers

+

A scheduler controls when a subscription starts and when notifications are published. It consists of three components. It is first a data structure. When you schedule for tasks to be completed, they are put into the scheduler for queueing based on priority or other criteria. It also offers an execution context which denotes where the task is executed (e.g., in the thread pool, current thread, or in another app domain). Lastly, it has a clock which provides a notion of time for itself (by accessing the Now property of a scheduler). Tasks being scheduled on a particular scheduler will adhere to the time denoted by that clock only.

+ +

Using Schedulers

+

You may have already used schedulers in your Rx code without explicitly stating the type of schedulers to be used. This is because all Observable operators that deal with concurrency have multiple overloads. If you do not use the overload which takes a scheduler as an argument, Rx will pick a default scheduler by using the principle of least concurrency. This means that the scheduler which introduces the least amount of concurrency that satisfies the needs of the operator is chosen. For example, for operators returning an observable with a finite and small number of messages, Rx calls ImmediateScheduler. For operators returning a potentially large or infinite number of messages, CurrentThread is called.

+

In the following example, the source observable sequences are each running in their own threads using EventLoopScheduler.

+ +auto input1 = std::make_shared<rxcpp::EventLoopScheduler>();
+ auto input2 = std::make_shared<rxcpp::EventLoopScheduler>();
+ auto output = std::make_shared<rxcpp::EventLoopScheduler>();

+ + auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers
+ auto s1 = rxcpp::from(values1)
+ .subscribe_on(input1)
+ .select([](int data) -> std::tuple<const char *, int> { return std::make_tuple("1:", data);})
+ .take(3);

+ + auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers
+ auto s2 = rxcpp::from(values2)
+ .subscribe_on(input2)
+ .select([](int data) -> std::tuple<const char *, int> { return std::make_tuple("2:", data);})
+ .take(3);

+ + rxcpp::from(s1)
+ .concat(s2)
+ .observe_on(output)
+ .for_each(rxcpp::MakeTupleDispatch(
+ [](const char* s, int p) {
+ cout << p << endl;
+ })); + +

This will queue up on the observer quickly. We can improve this code by using the observe_on operator, which allows you to specify the context that you want to use to send pushed notifications (OnNext) to observers. By default, the observe_on operator ensures that OnNext will be called as many times as possible on the current thread. You can use its overloads and redirect the OnNext outputs to a different context. In addition, you can use the subscribe_on operator to return a proxy observable that delegates actions to a specific scheduler. For example, for a UI-intensive application, you can delegate all background operations to be performed on a scheduler running in the background by using subscribe_on and passing to it a Concurrency.EventLoopScheduler.

+

You should also note that by using the observe_on operator, an action is scheduled for each message that comes through the original observable sequence. This potentially changes timing information as well as puts additional stress on the system. If you have a query that composes various observable sequences running on many different execution contexts, and you are doing filtering in the query, it is best to place observe_on later in the query. This is because a query will potentially filter out a lot of messages, and placing the observe_on operator earlier in the query would do extra work on messages that would be filtered out anyway. Calling the observe_on operator at the end of the query will create the least performance impact.

+ +

Implementing Your Own Operators for Observable

+

You can extend Rx by adding new operators for operations that are not provided by the LINQ library, or by creating your own implementation of standard query operators to improve readability and performance. Writing a customized version of a standard LINQ operator is useful when you want to operate with in-memory objects and when the intended customization does not require a comprehensive view of the query.

+ +

Creating New Operators

+

LINQ offers a full set of operators that cover most of the possible operations on a set of entities. However, you might need an operator to add a particular semantic meaning to your queryespecially if you can reuse that same operator several times in your code.

+

By reusing existing LINQ operators when you build a new one, you can take advantage of the existing performance or exception handling capabilities implemented in the Rx libraries.

+

When writing a custom operator, it is good practice not to leave any disposables unused; otherwise, you may find that resources could actually be leaked and cancellation may not work correctly.

+ +

Customizing Existing Operators

+

Adding new operators to LINQ is a way to extend its capabilities. However, you can also improve code readability by wrapping existing operators into more specialized and meaningful ones.

-- GitLab From 6aa0f1d68d16ad805063da0bfd7de3cd0b66674b Mon Sep 17 00:00:00 2001 From: Donna Malayeri Date: Wed, 4 Sep 2013 14:55:27 -0700 Subject: [PATCH 074/782] Expanded documentation in readme.md --- README.md | 367 +++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 353 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index bb32490..9616b37 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,359 @@ -# Reactive Extensions: +# Reactive Extensions for C++ (RxCpp) -* Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. -* RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. -* Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. +Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. -# Interactive Extensions -* Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. -* IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. -* Ix++: An implantation of LINQ for Native Developers in C++ +Data sequences can take many forms, such as a stream of data from a file or web service, web services requests, system notifications, or a series of events such as user input. -# Applications: -* Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. -* LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. +Reactive Extensions represents all these data sequences as observable sequences. An application can subscribe to these observable sequences to receive asynchronous notifications as new data arrives. The Rx library is available for application development in C%2B%2B, .NET, Ruby, Python, Silverlight, Windows Phone 7 and JavaScript. For more information on these different platforms, see Differences Between Versions of Rx topic. -#Contributing Code +## Pulling vs. Pushing Data -Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. +In interactive programming, the application actively polls a data source for more information by pulling data from a sequence that represents the source. The iterator allows us to get the current item by returning the current property, and determines whether there are more items to iterate (by calling some on_next method). -You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. \ No newline at end of file +The application is active in the data retrieval process, controlling the pace of the retrieval by calling on_next at its own convenience. This pattern is synchronous, which means that the application might be blocked while polling the data source. Such pulling pattern is similar to visiting your library and checking out a book. After you are done with the book, you pay another visit to check out another one. + +On the other hand, in reactive programming, the application is offered more information by subscribing to a data stream (called observable sequence in Rx), and any update is handed to it from the source. The application is passive in the data retrieval process: apart from subscribing to the observable source, it does not actively poll the source, but merely reacts to the data being pushed to it. When the stream has no more data to offer, or when it errs, the source will send a notice to the subscriber. In this way, the application will not be blocked by waiting for the source to update. + +This is the push pattern employed by Reactive Extensions. It is similar to joining a book club in which you register your interest in a particular genre, and books that match your interest are automatically sent to you as they are published. You do not need to stand in line to acquire something that you want. Employing a push pattern is helpful in many scenarios, especially in a UI-heavy environment in which the UI thread cannot be blocked while the application is waiting for some events. In summary, by using Rx, you can make your application more responsive. + +The push model implemented by Rx is represented by the observable pattern of Rx.Observable/Observer. The Rx.Observable will notify all the observers automatically of any state changes. To register an interest through a subscription, you use the subscribe method of Rx.Observable, which takes on an Observer and returns a disposable. This gives you the ability to track and dispose of the subscription. In addition, Rxs LINQ implementation over observable sequences allows developers to compose complex event processing queries over push-based sequences such as events, APM-based (AsyncResult) computations, Task-based computations, and asynchronous workflows. For more information on the Observable/Observer classes, see Exploring The Major Classes in Rx. For tutorials on using the different features in Rx, see Using Rx. + +This section describes in general what Reactive Extensions (Rx) is, and how it can benefit programmers who are creating asynchronous applications. + +### In This Section + +1\. When Will You Use Rx +2\. Installing Rx +3\. Differences Between Versions of Rx + +### Related Sections + +Using Rx +Reactive Extensions on MSDN Developer Center + +This topic describes the advantage of using Rx for users who are currently using the .NET event model for asynchronous programming. + +## Advantages of using Rx + +Whether you are authoring a traditional desktop or web-based application, you have to deal with asynchronous programming from time to time. Desktop applications have I/O or UI threads that might take a long time to complete and potentially block all other active threads. However, a user of the modern asynchronous programming model has to manage exceptions and cancellation of events manually. To compose or filter events, he has to write custom code that is hard to decipher and maintain. + +In addition, if your application interacts with multiple sources of data, the conventional way to manage all of these interactions is to implement separate methods as event handlers for each of these data streams. For example, as soon as a user types a character, a keydown event is pushed to your keydown event handler method. Inside this keydown event handler, you have to provide code to react to this event, or to coordinate between all of the different data streams and process this data into a useable form. + +Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer class. The Observable class maintains a list of dependent Observer threads and notifies them automatically of any state changes. You can query observable sequences using standard LINQ query operators implemented by the Rx.Observable type. Thus you can filter, aggregate, and compose on multiple events easily by using these LINQ operators. Cancellation and exceptions can also be handled gracefully by using extension methods provided by Rx. + +The following example shows how easy it is to implement an observable in C%2B%2B. + +` //Declare an observable +auto values1 = rxcpp::Range(1, 10); +rxcpp::from(values1) +.for_each( +[](int p) { +cout }); ` + +You can also use schedulers to control when the subscription starts, and when notifications are pushed to subscribers. For more information on this, see Using Schedulers for Concurrency Control. + +## Filtering + +One drawback of the C%2B%2B event model is that your event handler is always called every time an event is raised, and events arrive exactly as they were sent out by the source. To filter out events that you are not interested in, or transform data before your handler is called, you have to add custom filter logic to your handler. + +Take an application that detects mouse-down as an example. In the current event programming model, the application can react to the event raised by displaying a message. In Rx, such mouse-down events are treated as a stream of information about clicks. Whenever you click the mouse, information (e.g., cursor position) about this click appears in a stream, ready to be processed. In this paradigm, events (or event streams) are very similar to lists or other collections. This means that we can use techniques for working with collections to process events. For example, you can filter out those clicks that appear outside a specific area, and only display a message when the user clicks inside an area. Or you can wait a specific period of time, and inform the user the number of valid clicks during this period. Similarly, you can capture a stream of stock ticks and only respond to those ticks that have changed for a specific range during a particular time window. All these can be done easily by using LINQ-query style operators provided by Rx. + +In this way, a function can take an event, process it, and then pass out the processed stream to an application. This gives you flexibility that is not available in the current programming model. Moreover, as Rx is performing all the plumbing work at the background for filtering, synchronizing, and transforming the data, your handler can just react to the data it receives and do something with it. This results in cleaner code that is easier to read and maintain. For more information on filtering, see Querying Observable Collections using LINQ Operators. + +## Manipulating Events + +Rx represents events as a collection of objects: e.g., a OnMouseMove event contains a collection of Point values. Due to the first-class object nature of observables, they can be passed around as function parameters and returns, or stored in a variable. + +This topic describes where you can download the Reactive Extensions (Rx) SDK. + +## To download Rx + +Reactive Extensions is available for different platforms such as C%2B%2B, Javascript, .NET Framework 3.5, 4.0, 4.5, Silverlight 3 and 4, as well as Windows Phone 7 & 8\. You can download the libraries, as well as learn about their prerequisites at the [Rx MSDN Developer Center.][1] + +The following topic describes the various platforms for which you can develop solutions using Reactive Extensions. + +To get the latest release of Rx, as well as learn about its prerequisites, please visit the [Rx MSDN Developer Center][1]. + +## C%2B%2B + +The Reactive Extensions for C%2B%2B (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in C%2B%2B. + +## Javascript + +Rx for Javascript (RxJS) allows you to use LINQ operators in JavaScript. It provides easy-to-use conversions from existing DOM, XmlHttpRequest (AJAX), and jQuery events to push-based observable collections, allowing users to seamlessly integrate Rx into their existing JavaScript-based websites. + +RxJS brings similar capabilities to client script and integrates with jQuery events (Rx.Observable.FromJQueryEvent). It also supports Script#. + +## Ruby + +Rx for Ruby (Rx.rb) allows you to use Linq operators to create push-based observable collections in Ruby. + +## Python + +RX for Python (Rx.py) allows you to use Linq operators in Python. Rx.py allows you to implement push-based observable collections, allowing users to seamlessly integrate Rx into their existing Python applications. + +## .NET Framework + +The core Rx interfaces, IObservable and IObserver, ship as part of .NET Framework 4. If you are running on .NET Framework 3.5 SP1, or if you want to take advantage of the LINQ operators implemented in Observable type, as well as many other features such as schedulers, you can download the Rx header-only library in the [Rx MSDN Developer Center][1]. + +## Silverlight + +Silverlight disallows you from making cross-threading calls, thus you cannot use a background thread to update the UI. Instead of writing verbose code using the Dispatcher.BeginInvoke call to explicitly execute code on the main UI thread, you can use the factory Observable.Start method provided by the Rx header-only library to invoke an action asynchronously. Cross-threading is taken care of transparently by Rx under the hood. + +You can also use the various Observable operator overloads that take in a Scheduler, and specify the System.Reactive.Concurrency.DispatcherScheduler to be used. + +## Windows Phone + +Windows Phone 7 ships with a version of the Reactive Extensions baked into the ROM of the device. For more information, see [Reactive Extensions for .NET Overview for Windows Phone][2]. Documentation for this version of the Reactive Extensions can be found in Windows Phone API library at [Microsoft.Phone.Reactive Namespace][3]. + +The [Rx MSDN Developer Center][1] also contains an updated version of Rx for WP7, which has new definitions in the System.Reactive.Linq namespace. Note that the new APIs will not clash with the library built in to the phone (nor do they replace the version in the ROM). For more information on the differences of these 2 versions, see this [Rx team blog post][4]. + +Rx is available for Windows Phone 8 as well as Windows Phone 7. A .NET portable library is available using Nuget that is useful for developing libraries that work on Windows Phone, Windows Store apps, and in classic Windows desktop or server applications. + +This section includes topics that explain how you use Rx to create and subscribe to sequences, bridge existing events and existing asynchronous patterns, as well as using schedulers. It also describes more advanced tasks such as implementing your own operators. + +### In This Section + +1\. Exploring The Major Interfaces in Rx +2\. Creating and Querying Event Streams +3\. Subjects +6\. Implementing your own operators for IObservable +7\. Using Observable Providers + +This topic describes the major Reactive Extensions (Rx) interfaces used to represent observable sequences and subscribe to them. + +## Observable/Observer + +Rx exposes asynchronous and event-based data sources as push-based, observable sequences. This Observable class represents a data source that can be observed, meaning that it can send data to anyone who is interested. It maintains a list of dependent Observer implementations representing such interested listeners, and notifies them automatically of any state changes. + +As described in What is Rx, the other half of the push model is represented by the Observer class, which represents an observer who registers an interest through a subscription. Items are subsequently handed to the observer from the observable sequence to which it subscribes. + +In order to receive notifications from an observable collection, you use the subscribe method of Observable to hand it an Observer object. In return for this observer, the subscribe method returns a disposable object that acts as a handle for the subscription. This allows you to clean up the subscription after you are done. Calling dispose on this object detaches the observer from the source so that notifications are no longer delivered. As you can infer, in Rx you do not need to explicitly unsubscribe from an event. + +Observers support three publication events, reflected by the interfaces methods. OnNext can be called zero or more times, when the observable data source has data available. For example, an observable data source used for mouse move events can send out a Point object every time the mouse has moved. The other two methods are used to indicate completion or errors. + +The following lists the Observable/Observer definitions. + +` namespace rxcpp { +template +struct Observer +{ +virtual void OnNext(const T&) {}; +virtual void OnCompleted() {}; +virtual void OnError(const std::exception_ptr&) {}; + +virtual ~Observer() {} +}; +template +struct Observable +{ +virtual Disposable Subscribe(std::shared_ptr> observer) = 0; +virtual ~Observable() {} +}; +} + +` + +Note that the OnError event returns an exception_ptr type. The example above shows passing the error to a handler function. + +You can treat the observable sequence (such as a sequence of mouse-over events) as if it were a normal collection. Thus you can write LINQ queries over the collection to do things like filtering, grouping, composing, etc. To make observable sequences more useful, the Rx header-only library provides many factory LINQ operators so that you do not need to implement any of these on your own. This will be covered in the Querying Observable Collections using LINQ Operators topic. + +### See Also + +Creating and Subscribing to Simple Observable Sequences Querying Observable Collections using LINQ Operators + +This section describes how you can create and subscribe to an observable sequence, convert an existing C%2B%2B event into a sequence and query it. + +### In This Section + +Creating and Subscribing to Simple Observable Sequences +Querying Observable Collections using LINQ Operators + +You do not need to implement the Observable interface manually to create an observable sequences. Similarly, you do not need to implement Observer either to subscribe to a sequence. By installing the Reactive Extension header-only library, you can take advantage of the Observable type which provides many LINQ operators for you to create a simple sequence with zero, one or more elements. In addition, Rx provides Subscribe methods that take various combinations of OnNext, OnError and OnCompleted handlers in terms of delegates. + +## Creating and subscribing to a simple sequence + +The following sample uses the range operator of the Observable type to create a simple observable collection of numbers. The observer subscribes to this collection using the Subscribe method of the Observable class, and provides actions that are delegates which handle OnNext, OnCompleted and OnError. + +The range operator has several overloads. In our example, it creates a sequence of integers that starts with x and produces y sequential numbers afterwards. + +As soon as the subscription happens, the values are sent to the observer. The OnNext delegate then prints out the values. + +` auto values1 = rxcpp::Range(1, 10); +rxcpp::from(values1) +.for_each( +[](int p) { +cout }); ` + +When an observer subscribes to an observable sequence, the thread calling the subscribe method can be different from the thread in which the sequence runs till completion. Therefore, the subscribe call is asynchronous in that the caller is not blocked until the observation of the sequence completes. This will be covered in more details in the Using Schedulers topic. + +Notice that the subscribe method returns a Disposable, so that you can unsubscribe to a sequence and dispose of it easily. When you invoke the Dispose method on the observable sequence, the observer will stop listening to the observable for data. Normally, you do not need to explicitly call Dispose unless you need to unsubscribe early, or when the source observable sequence has a longer life span than the observer. Subscriptions in Rx are designed for fire-and-forget scenarios without the usage of a finalizer. When the Disposable instance is collected by the garbage collector, Rx does not automatically dispose of the subscription. However, note that the default behavior of the Observable operators is to dispose of the subscription as soon as possible (i.e, when an OnCompleted or OnError messages is published). + +In addition to creating an observable sequence from scratch, you can convert existing enumerators, C%2B%2B events and asynchronous patterns into observable sequences. The other topics in this section will show you how to do this. + +Notice that this topic only shows you a few operators that can create an observable sequence from scratch. To learn more about other LINQ operators, see Query Observable Collections using LINQ Operators. + +## Converting an Enumerable Collection to an Observable Sequence + +Using the Iterate operator, you can convert an array colection to an observable sequence and subscribe to it. + +` std::array a={1, 2, 3}; +auto values1 = rxcpp::Iterate(a); + +rxcpp::from(values1) +.for_each( +[](int p) { +cout }); + +` + +### See Also + +Query Observable Collections using LINQ Operators + +We have converted existing C%2B%2B events into observable sequences to subscribe to them. In this topic, we will look at the first-class nature of observable sequences as Observable objects, in which generic LINQ operators are supplied by the Rx header-only library to manipulate these objects. Most operators take an observable sequence and perform some logic on it and output another observable sequence. In addition, as you can see from our code samples, you can even chain multiple operators on a source sequence to tweak the resulting sequence to your exact requirement. + +## Using Different Operators + +We have already used the Create and Generate operators in previous topics to create and return simple sequences. In this topic, we will use other LINQ operators of the Observable type so that you can filter, group and transform data. Such operators take observable sequence(s) as input, and produce observable sequence(s) as output. + +## Combining different sequences + +In this section, we will examine some of the operators that combine various observable sequences into a single observable sequence. Notice that data are not transformed when we combine sequences. + +In the following sample, we use the concat operator to combine two sequences into a single sequence and subscribe to it. + +` auto input1 = std::make_shared(); +auto input2 = std::make_shared(); +auto output = std::make_shared(); + +auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers +auto s1 = rxcpp::from(values1) +.subscribe_on(input1) +.select([](int prime) -> std::tuple { return std::make_tuple("1:", prime);}) +.take(3); + +auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers +auto s2 = rxcpp::from(values2) +.subscribe_on(input2) +.select([](int prime) -> std::tuple { return std::make_tuple("2:", prime);}) +.take(3); + +rxcpp::from(s1) +.concat(s2) +.observe_on(output) +.for_each(rxcpp::MakeTupleDispatch( +[](const char* s, int p) { +cout })); + +` + +Notice that the resultant sequence is 1,2,3,1,2,3. This is because when you use the concat operator, the 2nd sequence (source2) will not be active until after the 1st sequence (source1) has finished pushing all its values. It is only after source1 has completed, then source2 will start to push values to the resultant sequence. The subscriber will then get all the values from the resultant sequence. + +Compare this with the merge operator. If you run the following sample code, you will get 1,1,2,2,3,3. This is because the two sequences are active at the same time and values are pushed out as they occur in the sources. The resultant sequence only completes when the last source sequence has finished pushing values. + +Notice that for Merge to work, all the source observable sequences need to be of the same type of Observable. The resultant sequence will be of the type Observable. If source1 produces an OnError in the middle of the sequence, then the resultant sequence will complete immediately. + +` auto input1 = std::make_shared(); +auto input2 = std::make_shared(); +auto output = std::make_shared(); + +auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers +auto s1 = rxcpp::from(values1) +.subscribe_on(input1) +.select([](int data) -> std::tuple { return std::make_tuple("1: ", data);}); + +auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers +rxcpp::from(values2) +.subscribe_on(input1) +.select([](int data) -> std::tuple { return std::make_tuple("2: ", data);}) +.merge(s1) +.take(6) +.observe_on(output) +.for_each(rxcpp::MakeTupleDispatch( +[](const char* s, int p) { +cout })); + +` + +Notice that for these combination operators to work, all the observable sequences need to be of the same type. + +This section describes the Subject type implemented by Reactive Extensions. It also describes various implementations of Subject which serves different purposes. + +### In This Section + +1\. Using Subjects + +The Subject type implements both Observable and Observer, in the sense that it is both an observer and an observable. You can use a subject to subscribe all the observers, and then subscribe the subject to a backend data source. In this way, the subject can act as a proxy for a group of subscribers and a source. You can use subjects to implement a custom observable with caching, buffering and time shifting. In addition, you can use subjects to broadcast data to multiple subscribers. + +By default, subjects do not perform any synchronization across threads. They do not take a scheduler but rather assume that all serialization and grammatical correctness are handled by the caller of the subject. A subject simply broadcasts to all subscribed observers in the thread-safe list of subscribers. Doing so has the advantage of reducing overhead and improving performance. If, however, you want to synchronize outgoing calls to observers using a scheduler, you can use the Synchronize method to do so. + +## Different types of Subjects + +The Subject type in the Rx library is a basic implementation of the Subject interface (you can also implement the Subject interface to create your own subject types). There are other implementations of Subject that offer different functionalities. All of these types store some (or all of) values pushed to them via OnNext, and broadcast it back to its observers. This means that if you subscribe to any of these more than once (i.e. subscribe -> unsubscribe -> subscribe again), you will see at least one of the same value again. + +This section describes how you can use a scheduler to control when to start a sequence or subscribe to an event. + +The various Scheduler types provided by Rx are: + +ImmediateScheduler: Default scheduler, pushes notifications as they are recieved. + +EventLoopScheduler: Used when creating a separate thread for Rx sequences. + +A scheduler controls when a subscription starts and when notifications are published. It consists of three components. It is first a data structure. When you schedule for tasks to be completed, they are put into the scheduler for queueing based on priority or other criteria. It also offers an execution context which denotes where the task is executed (e.g., in the thread pool, current thread, or in another app domain). Lastly, it has a clock which provides a notion of time for itself (by accessing the Now property of a scheduler). Tasks being scheduled on a particular scheduler will adhere to the time denoted by that clock only. + +## Using Schedulers + +You may have already used schedulers in your Rx code without explicitly stating the type of schedulers to be used. This is because all Observable operators that deal with concurrency have multiple overloads. If you do not use the overload which takes a scheduler as an argument, Rx will pick a default scheduler by using the principle of least concurrency. This means that the scheduler which introduces the least amount of concurrency that satisfies the needs of the operator is chosen. For example, for operators returning an observable with a finite and small number of messages, Rx calls ImmediateScheduler. For operators returning a potentially large or infinite number of messages, CurrentThread is called. + +In the following example, the source observable sequences are each running in their own threads using EventLoopScheduler. + +` auto input1 = std::make_shared(); +auto input2 = std::make_shared(); +auto output = std::make_shared(); + +auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers +auto s1 = rxcpp::from(values1) +.subscribe_on(input1) +.select([](int data) -> std::tuple { return std::make_tuple("1:", data);}) +.take(3); + +auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers +auto s2 = rxcpp::from(values2) +.subscribe_on(input2) +.select([](int data) -> std::tuple { return std::make_tuple("2:", data);}) +.take(3); + +rxcpp::from(s1) +.concat(s2) +.observe_on(output) +.for_each(rxcpp::MakeTupleDispatch( +[](const char* s, int p) { +cout })); + +` + +This will queue up on the observer quickly. We can improve this code by using the observe_on operator, which allows you to specify the context that you want to use to send pushed notifications (OnNext) to observers. By default, the observe_on operator ensures that OnNext will be called as many times as possible on the current thread. You can use its overloads and redirect the OnNext outputs to a different context. In addition, you can use the subscribe_on operator to return a proxy observable that delegates actions to a specific scheduler. For example, for a UI-intensive application, you can delegate all background operations to be performed on a scheduler running in the background by using subscribe_on and passing to it a Concurrency.EventLoopScheduler. + +You should also note that by using the observe_on operator, an action is scheduled for each message that comes through the original observable sequence. This potentially changes timing information as well as puts additional stress on the system. If you have a query that composes various observable sequences running on many different execution contexts, and you are doing filtering in the query, it is best to place observe_on later in the query. This is because a query will potentially filter out a lot of messages, and placing the observe_on operator earlier in the query would do extra work on messages that would be filtered out anyway. Calling the observe_on operator at the end of the query will create the least performance impact. + +You can extend Rx by adding new operators for operations that are not provided by the LINQ library, or by creating your own implementation of standard query operators to improve readability and performance. Writing a customized version of a standard LINQ operator is useful when you want to operate with in-memory objects and when the intended customization does not require a comprehensive view of the query. + +## Creating New Operators + +LINQ offers a full set of operators that cover most of the possible operations on a set of entities. However, you might need an operator to add a particular semantic meaning to your queryespecially if you can reuse that same operator several times in your code. + +By reusing existing LINQ operators when you build a new one, you can take advantage of the existing performance or exception handling capabilities implemented in the Rx libraries. + +When writing a custom operator, it is good practice not to leave any disposables unused; otherwise, you may find that resources could actually be leaked and cancellation may not work correctly. + +## Customizing Existing Operators + +Adding new operators to LINQ is a way to extend its capabilities. However, you can also improve code readability by wrapping existing operators into more specialized and meaningful ones. + + [1]: http://msdn.microsoft.com/en-us/data/gg577609 + [2]: http://msdn.microsoft.com/en-us/library/ff431792(VS.92).aspx + [3]: http://msdn.microsoft.com/en-us/library/ff707857(v=VS.92).aspx + [4]: http://blogs.msdn.com/b/rxteam/archive/2010/10/28/rx-for-windows-phone-7.aspx + + \ No newline at end of file -- GitLab From 128bba0ec707c558fa66840eb8ccc67ffebcf3f0 Mon Sep 17 00:00:00 2001 From: Donna Malayeri Date: Wed, 4 Sep 2013 15:02:33 -0700 Subject: [PATCH 075/782] Fix formatting in readme.md --- README.md | 142 +++++++++++++++++++++++++++--------------------------- 1 file changed, 70 insertions(+), 72 deletions(-) diff --git a/README.md b/README.md index 9616b37..673496e 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ Reactive Extensions (Rx) is a library for composing asynchronous and event-based Data sequences can take many forms, such as a stream of data from a file or web service, web services requests, system notifications, or a series of events such as user input. -Reactive Extensions represents all these data sequences as observable sequences. An application can subscribe to these observable sequences to receive asynchronous notifications as new data arrives. The Rx library is available for application development in C%2B%2B, .NET, Ruby, Python, Silverlight, Windows Phone 7 and JavaScript. For more information on these different platforms, see Differences Between Versions of Rx topic. +Reactive Extensions represents all these data sequences as observable sequences. An application can subscribe to these observable sequences to receive asynchronous notifications as new data arrives. The Rx library is available for application development in C++, .NET, Ruby, Python, Silverlight, Windows Phone 7 and JavaScript. For more information on these different platforms, see Differences Between Versions of Rx topic. ## Pulling vs. Pushing Data @@ -41,20 +41,21 @@ In addition, if your application interacts with multiple sources of data, the co Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer class. The Observable class maintains a list of dependent Observer threads and notifies them automatically of any state changes. You can query observable sequences using standard LINQ query operators implemented by the Rx.Observable type. Thus you can filter, aggregate, and compose on multiple events easily by using these LINQ operators. Cancellation and exceptions can also be handled gracefully by using extension methods provided by Rx. -The following example shows how easy it is to implement an observable in C%2B%2B. +The following example shows how easy it is to implement an observable in C++. -` //Declare an observable -auto values1 = rxcpp::Range(1, 10); -rxcpp::from(values1) -.for_each( -[](int p) { -cout }); ` + //Declare an observable
+ auto values1 = rxcpp::Range(1, 10);
+ rxcpp::from(values1)
+ .for_each(
+ [](int p) {
+ cout << p << endl;
+ }); You can also use schedulers to control when the subscription starts, and when notifications are pushed to subscribers. For more information on this, see Using Schedulers for Concurrency Control. ## Filtering -One drawback of the C%2B%2B event model is that your event handler is always called every time an event is raised, and events arrive exactly as they were sent out by the source. To filter out events that you are not interested in, or transform data before your handler is called, you have to add custom filter logic to your handler. +One drawback of the C++ event model is that your event handler is always called every time an event is raised, and events arrive exactly as they were sent out by the source. To filter out events that you are not interested in, or transform data before your handler is called, you have to add custom filter logic to your handler. Take an application that detects mouse-down as an example. In the current event programming model, the application can react to the event raised by displaying a message. In Rx, such mouse-down events are treated as a stream of information about clicks. Whenever you click the mouse, information (e.g., cursor position) about this click appears in a stream, ready to be processed. In this paradigm, events (or event streams) are very similar to lists or other collections. This means that we can use techniques for working with collections to process events. For example, you can filter out those clicks that appear outside a specific area, and only display a message when the user clicks inside an area. Or you can wait a specific period of time, and inform the user the number of valid clicks during this period. Similarly, you can capture a stream of stock ticks and only respond to those ticks that have changed for a specific range during a particular time window. All these can be done easily by using LINQ-query style operators provided by Rx. @@ -68,15 +69,15 @@ This topic describes where you can download the Reactive Extensions (Rx) SDK. ## To download Rx -Reactive Extensions is available for different platforms such as C%2B%2B, Javascript, .NET Framework 3.5, 4.0, 4.5, Silverlight 3 and 4, as well as Windows Phone 7 & 8\. You can download the libraries, as well as learn about their prerequisites at the [Rx MSDN Developer Center.][1] +Reactive Extensions is available for different platforms such as C++, Javascript, .NET Framework 3.5, 4.0, 4.5, Silverlight 3 and 4, as well as Windows Phone 7 & 8\. You can download the libraries, as well as learn about their prerequisites at the [Rx MSDN Developer Center.][1] The following topic describes the various platforms for which you can develop solutions using Reactive Extensions. To get the latest release of Rx, as well as learn about its prerequisites, please visit the [Rx MSDN Developer Center][1]. -## C%2B%2B +## C++ -The Reactive Extensions for C%2B%2B (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in C%2B%2B. +The Reactive Extensions for C++ (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in C++. ## Javascript @@ -114,11 +115,11 @@ This section includes topics that explain how you use Rx to create and subscribe ### In This Section -1\. Exploring The Major Interfaces in Rx -2\. Creating and Querying Event Streams -3\. Subjects -6\. Implementing your own operators for IObservable -7\. Using Observable Providers +1. Exploring The Major Interfaces in Rx +2. Creating and Querying Event Streams +3. Subjects +6. Implementing your own operators for IObservable +7. Using Observable Providers This topic describes the major Reactive Extensions (Rx) interfaces used to represent observable sequences and subscribe to them. @@ -134,25 +135,24 @@ Observers support three publication events, reflected by the interfaces methods. The following lists the Observable/Observer definitions. -` namespace rxcpp { -template -struct Observer -{ -virtual void OnNext(const T&) {}; -virtual void OnCompleted() {}; -virtual void OnError(const std::exception_ptr&) {}; - -virtual ~Observer() {} -}; -template -struct Observable -{ -virtual Disposable Subscribe(std::shared_ptr> observer) = 0; -virtual ~Observable() {} -}; -} - -` + namespace rxcpp { + template + struct Observer + { + virtual void OnNext(const T&) {}; + virtual void OnCompleted() {}; + virtual void OnError(const std::exception_ptr&) {}; + + virtual ~Observer() {} + }; + + template + struct Observable + { + virtual Disposable Subscribe(std::shared_ptr> observer) = 0; + virtual ~Observable() {} + }; + } Note that the OnError event returns an exception_ptr type. The example above shows passing the error to a handler function. @@ -162,7 +162,7 @@ You can treat the observable sequence (such as a sequence of mouse-over events) Creating and Subscribing to Simple Observable Sequences Querying Observable Collections using LINQ Operators -This section describes how you can create and subscribe to an observable sequence, convert an existing C%2B%2B event into a sequence and query it. +This section describes how you can create and subscribe to an observable sequence, convert an existing C++ event into a sequence and query it. ### In This Section @@ -179,17 +179,17 @@ The range operator has several overloads. In our example, it creates a sequence As soon as the subscription happens, the values are sent to the observer. The OnNext delegate then prints out the values. -` auto values1 = rxcpp::Range(1, 10); -rxcpp::from(values1) -.for_each( -[](int p) { -cout }); ` + auto values1 = rxcpp::Range(1, 10); + rxcpp::from(values1) + .for_each( + [](int p) { + cout }); When an observer subscribes to an observable sequence, the thread calling the subscribe method can be different from the thread in which the sequence runs till completion. Therefore, the subscribe call is asynchronous in that the caller is not blocked until the observation of the sequence completes. This will be covered in more details in the Using Schedulers topic. Notice that the subscribe method returns a Disposable, so that you can unsubscribe to a sequence and dispose of it easily. When you invoke the Dispose method on the observable sequence, the observer will stop listening to the observable for data. Normally, you do not need to explicitly call Dispose unless you need to unsubscribe early, or when the source observable sequence has a longer life span than the observer. Subscriptions in Rx are designed for fire-and-forget scenarios without the usage of a finalizer. When the Disposable instance is collected by the garbage collector, Rx does not automatically dispose of the subscription. However, note that the default behavior of the Observable operators is to dispose of the subscription as soon as possible (i.e, when an OnCompleted or OnError messages is published). -In addition to creating an observable sequence from scratch, you can convert existing enumerators, C%2B%2B events and asynchronous patterns into observable sequences. The other topics in this section will show you how to do this. +In addition to creating an observable sequence from scratch, you can convert existing enumerators, C++ events and asynchronous patterns into observable sequences. The other topics in this section will show you how to do this. Notice that this topic only shows you a few operators that can create an observable sequence from scratch. To learn more about other LINQ operators, see Query Observable Collections using LINQ Operators. @@ -197,21 +197,20 @@ Notice that this topic only shows you a few operators that can create an observa Using the Iterate operator, you can convert an array colection to an observable sequence and subscribe to it. -` std::array a={1, 2, 3}; -auto values1 = rxcpp::Iterate(a); + std::array a={1, 2, 3}; + auto values1 = rxcpp::Iterate(a); -rxcpp::from(values1) -.for_each( -[](int p) { -cout }); + rxcpp::from(values1) + .for_each( + [](int p) { + cout }); -` ### See Also Query Observable Collections using LINQ Operators -We have converted existing C%2B%2B events into observable sequences to subscribe to them. In this topic, we will look at the first-class nature of observable sequences as Observable objects, in which generic LINQ operators are supplied by the Rx header-only library to manipulate these objects. Most operators take an observable sequence and perform some logic on it and output another observable sequence. In addition, as you can see from our code samples, you can even chain multiple operators on a source sequence to tweak the resulting sequence to your exact requirement. +We have converted existing C++ events into observable sequences to subscribe to them. In this topic, we will look at the first-class nature of observable sequences as Observable objects, in which generic LINQ operators are supplied by the Rx header-only library to manipulate these objects. Most operators take an observable sequence and perform some logic on it and output another observable sequence. In addition, as you can see from our code samples, you can even chain multiple operators on a source sequence to tweak the resulting sequence to your exact requirement. ## Using Different Operators @@ -223,30 +222,29 @@ In this section, we will examine some of the operators that combine various obse In the following sample, we use the concat operator to combine two sequences into a single sequence and subscribe to it. -` auto input1 = std::make_shared(); -auto input2 = std::make_shared(); -auto output = std::make_shared(); + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); -auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers -auto s1 = rxcpp::from(values1) -.subscribe_on(input1) -.select([](int prime) -> std::tuple { return std::make_tuple("1:", prime);}) -.take(3); + auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .select([](int prime) ->; std::tuple { return std::make_tuple("1:", prime);}) + .take(3); -auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers -auto s2 = rxcpp::from(values2) -.subscribe_on(input2) -.select([](int prime) -> std::tuple { return std::make_tuple("2:", prime);}) -.take(3); + auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers + auto s2 = rxcpp::from(values2) + .subscribe_on(input2) + .select([](int prime) ->; std::tuple { return std::make_tuple("2:", prime);}) + .take(3); -rxcpp::from(s1) -.concat(s2) -.observe_on(output) -.for_each(rxcpp::MakeTupleDispatch( -[](const char* s, int p) { -cout })); + rxcpp::from(s1) + .concat(s2) + .observe_on(output) + .for_each(rxcpp::MakeTupleDispatch( + [](const char* s, int p) { + cout })); -` Notice that the resultant sequence is 1,2,3,1,2,3. This is because when you use the concat operator, the 2nd sequence (source2) will not be active until after the 1st sequence (source1) has finished pushing all its values. It is only after source1 has completed, then source2 will start to push values to the resultant sequence. The subscriber will then get all the values from the resultant sequence. @@ -282,7 +280,7 @@ This section describes the Subject type implemented by Reactive Extensions. It a ### In This Section -1\. Using Subjects +1. Using Subjects The Subject type implements both Observable and Observer, in the sense that it is both an observer and an observable. You can use a subject to subscribe all the observers, and then subscribe the subject to a backend data source. In this way, the subject can act as a proxy for a group of subscribers and a source. You can use subjects to implement a custom observable with caching, buffering and time shifting. In addition, you can use subjects to broadcast data to multiple subscribers. -- GitLab From b994f81fee6a92e82909c6d1ac2eb22b938ac705 Mon Sep 17 00:00:00 2001 From: Donna Malayeri Date: Wed, 4 Sep 2013 15:05:21 -0700 Subject: [PATCH 076/782] Update README.md --- README.md | 106 +++++++++++++++++++++++++++--------------------------- 1 file changed, 52 insertions(+), 54 deletions(-) diff --git a/README.md b/README.md index 673496e..dfee08b 100644 --- a/README.md +++ b/README.md @@ -22,9 +22,9 @@ This section describes in general what Reactive Extensions (Rx) is, and how it c ### In This Section -1\. When Will You Use Rx -2\. Installing Rx -3\. Differences Between Versions of Rx +1. When Will You Use Rx +2. Installing Rx +3. Differences Between Versions of Rx ### Related Sections @@ -252,27 +252,25 @@ Compare this with the merge operator. If you run the following sample code, you Notice that for Merge to work, all the source observable sequences need to be of the same type of Observable. The resultant sequence will be of the type Observable. If source1 produces an OnError in the middle of the sequence, then the resultant sequence will complete immediately. -` auto input1 = std::make_shared(); -auto input2 = std::make_shared(); -auto output = std::make_shared(); - -auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers -auto s1 = rxcpp::from(values1) -.subscribe_on(input1) -.select([](int data) -> std::tuple { return std::make_tuple("1: ", data);}); - -auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers -rxcpp::from(values2) -.subscribe_on(input1) -.select([](int data) -> std::tuple { return std::make_tuple("2: ", data);}) -.merge(s1) -.take(6) -.observe_on(output) -.for_each(rxcpp::MakeTupleDispatch( -[](const char* s, int p) { -cout })); - -` + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); + + auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .select([](int data) -> std::tuple { return std::make_tuple("1: ", data);}); + + auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers + rxcpp::from(values2) + .subscribe_on(input1) + .select([](int data) -> std::tuple { return std::make_tuple("2: ", data);}) + .merge(s1) + .take(6) + .observe_on(output) + .for_each(rxcpp::MakeTupleDispatch( + [](const char* s, int p) { + cout })); Notice that for these combination operators to work, all the observable sequences need to be of the same type. @@ -305,31 +303,30 @@ A scheduler controls when a subscription starts and when notifications are publi You may have already used schedulers in your Rx code without explicitly stating the type of schedulers to be used. This is because all Observable operators that deal with concurrency have multiple overloads. If you do not use the overload which takes a scheduler as an argument, Rx will pick a default scheduler by using the principle of least concurrency. This means that the scheduler which introduces the least amount of concurrency that satisfies the needs of the operator is chosen. For example, for operators returning an observable with a finite and small number of messages, Rx calls ImmediateScheduler. For operators returning a potentially large or infinite number of messages, CurrentThread is called. In the following example, the source observable sequences are each running in their own threads using EventLoopScheduler. - -` auto input1 = std::make_shared(); -auto input2 = std::make_shared(); -auto output = std::make_shared(); - -auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers -auto s1 = rxcpp::from(values1) -.subscribe_on(input1) -.select([](int data) -> std::tuple { return std::make_tuple("1:", data);}) -.take(3); - -auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers -auto s2 = rxcpp::from(values2) -.subscribe_on(input2) -.select([](int data) -> std::tuple { return std::make_tuple("2:", data);}) -.take(3); - -rxcpp::from(s1) -.concat(s2) -.observe_on(output) -.for_each(rxcpp::MakeTupleDispatch( -[](const char* s, int p) { -cout })); - -` + + auto input1 = std::make_shared(); + auto input2 = std::make_shared(); + auto output = std::make_shared(); + + auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers + auto s1 = rxcpp::from(values1) + .subscribe_on(input1) + .select([](int data) -> std::tuple { return std::make_tuple("1:", data);}) + .take(3); + + auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers + auto s2 = rxcpp::from(values2) + .subscribe_on(input2) + .select([](int data) -> std::tuple { return std::make_tuple("2:", data);}) + .take(3); + + rxcpp::from(s1) + .concat(s2) + .observe_on(output) + .for_each(rxcpp::MakeTupleDispatch( + [](const char* s, int p) { + cout })); + This will queue up on the observer quickly. We can improve this code by using the observe_on operator, which allows you to specify the context that you want to use to send pushed notifications (OnNext) to observers. By default, the observe_on operator ensures that OnNext will be called as many times as possible on the current thread. You can use its overloads and redirect the OnNext outputs to a different context. In addition, you can use the subscribe_on operator to return a proxy observable that delegates actions to a specific scheduler. For example, for a UI-intensive application, you can delegate all background operations to be performed on a scheduler running in the background by using subscribe_on and passing to it a Concurrency.EventLoopScheduler. @@ -349,9 +346,10 @@ When writing a custom operator, it is good practice not to leave any disposables Adding new operators to LINQ is a way to extend its capabilities. However, you can also improve code readability by wrapping existing operators into more specialized and meaningful ones. - [1]: http://msdn.microsoft.com/en-us/data/gg577609 - [2]: http://msdn.microsoft.com/en-us/library/ff431792(VS.92).aspx - [3]: http://msdn.microsoft.com/en-us/library/ff707857(v=VS.92).aspx - [4]: http://blogs.msdn.com/b/rxteam/archive/2010/10/28/rx-for-windows-phone-7.aspx + +http://msdn.microsoft.com/en-us/data/gg577609 +http://msdn.microsoft.com/en-us/library/ff431792(VS.92).aspx +http://msdn.microsoft.com/en-us/library/ff707857(v=VS.92).aspx +http://blogs.msdn.com/b/rxteam/archive/2010/10/28/rx-for-windows-phone-7.aspx + - \ No newline at end of file -- GitLab From 324e88a78258c27a56d115f981e3411f58f2b9c7 Mon Sep 17 00:00:00 2001 From: Donna Malayeri Date: Wed, 4 Sep 2013 15:10:58 -0700 Subject: [PATCH 077/782] Update README.md --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index dfee08b..f3f7c7e 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ -# Reactive Extensions for C++ (RxCpp) +Reactive Extensions for C++ (RxCpp) +===================================== Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. @@ -161,7 +162,7 @@ You can treat the observable sequence (such as a sequence of mouse-over events) ### See Also Creating and Subscribing to Simple Observable Sequences Querying Observable Collections using LINQ Operators - + This section describes how you can create and subscribe to an observable sequence, convert an existing C++ event into a sequence and query it. ### In This Section -- GitLab From a9c2c210309a93899c22ee2ccdaf9d16f5e6716f Mon Sep 17 00:00:00 2001 From: Donna Malayeri Date: Wed, 4 Sep 2013 15:47:23 -0700 Subject: [PATCH 078/782] Revert changes to .md file, since codeplex is not rendering properly --- README.md | 364 +++--------------------------------------------------- 1 file changed, 14 insertions(+), 350 deletions(-) diff --git a/README.md b/README.md index f3f7c7e..bb32490 100644 --- a/README.md +++ b/README.md @@ -1,356 +1,20 @@ -Reactive Extensions for C++ (RxCpp) -===================================== +# Reactive Extensions: -Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. +* Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. +* RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. +* Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. -Data sequences can take many forms, such as a stream of data from a file or web service, web services requests, system notifications, or a series of events such as user input. +# Interactive Extensions +* Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. +* IxJS: An implementation of LINQ to Objects and the Interactive Extensions (Ix) in JavaScript. +* Ix++: An implantation of LINQ for Native Developers in C++ -Reactive Extensions represents all these data sequences as observable sequences. An application can subscribe to these observable sequences to receive asynchronous notifications as new data arrives. The Rx library is available for application development in C++, .NET, Ruby, Python, Silverlight, Windows Phone 7 and JavaScript. For more information on these different platforms, see Differences Between Versions of Rx topic. +# Applications: +* Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. +* LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. -## Pulling vs. Pushing Data +#Contributing Code -In interactive programming, the application actively polls a data source for more information by pulling data from a sequence that represents the source. The iterator allows us to get the current item by returning the current property, and determines whether there are more items to iterate (by calling some on_next method). +Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. -The application is active in the data retrieval process, controlling the pace of the retrieval by calling on_next at its own convenience. This pattern is synchronous, which means that the application might be blocked while polling the data source. Such pulling pattern is similar to visiting your library and checking out a book. After you are done with the book, you pay another visit to check out another one. - -On the other hand, in reactive programming, the application is offered more information by subscribing to a data stream (called observable sequence in Rx), and any update is handed to it from the source. The application is passive in the data retrieval process: apart from subscribing to the observable source, it does not actively poll the source, but merely reacts to the data being pushed to it. When the stream has no more data to offer, or when it errs, the source will send a notice to the subscriber. In this way, the application will not be blocked by waiting for the source to update. - -This is the push pattern employed by Reactive Extensions. It is similar to joining a book club in which you register your interest in a particular genre, and books that match your interest are automatically sent to you as they are published. You do not need to stand in line to acquire something that you want. Employing a push pattern is helpful in many scenarios, especially in a UI-heavy environment in which the UI thread cannot be blocked while the application is waiting for some events. In summary, by using Rx, you can make your application more responsive. - -The push model implemented by Rx is represented by the observable pattern of Rx.Observable/Observer. The Rx.Observable will notify all the observers automatically of any state changes. To register an interest through a subscription, you use the subscribe method of Rx.Observable, which takes on an Observer and returns a disposable. This gives you the ability to track and dispose of the subscription. In addition, Rxs LINQ implementation over observable sequences allows developers to compose complex event processing queries over push-based sequences such as events, APM-based (AsyncResult) computations, Task-based computations, and asynchronous workflows. For more information on the Observable/Observer classes, see Exploring The Major Classes in Rx. For tutorials on using the different features in Rx, see Using Rx. - -This section describes in general what Reactive Extensions (Rx) is, and how it can benefit programmers who are creating asynchronous applications. - -### In This Section - -1. When Will You Use Rx -2. Installing Rx -3. Differences Between Versions of Rx - -### Related Sections - -Using Rx -Reactive Extensions on MSDN Developer Center - -This topic describes the advantage of using Rx for users who are currently using the .NET event model for asynchronous programming. - -## Advantages of using Rx - -Whether you are authoring a traditional desktop or web-based application, you have to deal with asynchronous programming from time to time. Desktop applications have I/O or UI threads that might take a long time to complete and potentially block all other active threads. However, a user of the modern asynchronous programming model has to manage exceptions and cancellation of events manually. To compose or filter events, he has to write custom code that is hard to decipher and maintain. - -In addition, if your application interacts with multiple sources of data, the conventional way to manage all of these interactions is to implement separate methods as event handlers for each of these data streams. For example, as soon as a user types a character, a keydown event is pushed to your keydown event handler method. Inside this keydown event handler, you have to provide code to react to this event, or to coordinate between all of the different data streams and process this data into a useable form. - -Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer class. The Observable class maintains a list of dependent Observer threads and notifies them automatically of any state changes. You can query observable sequences using standard LINQ query operators implemented by the Rx.Observable type. Thus you can filter, aggregate, and compose on multiple events easily by using these LINQ operators. Cancellation and exceptions can also be handled gracefully by using extension methods provided by Rx. - -The following example shows how easy it is to implement an observable in C++. - - //Declare an observable
- auto values1 = rxcpp::Range(1, 10);
- rxcpp::from(values1)
- .for_each(
- [](int p) {
- cout << p << endl;
- }); - -You can also use schedulers to control when the subscription starts, and when notifications are pushed to subscribers. For more information on this, see Using Schedulers for Concurrency Control. - -## Filtering - -One drawback of the C++ event model is that your event handler is always called every time an event is raised, and events arrive exactly as they were sent out by the source. To filter out events that you are not interested in, or transform data before your handler is called, you have to add custom filter logic to your handler. - -Take an application that detects mouse-down as an example. In the current event programming model, the application can react to the event raised by displaying a message. In Rx, such mouse-down events are treated as a stream of information about clicks. Whenever you click the mouse, information (e.g., cursor position) about this click appears in a stream, ready to be processed. In this paradigm, events (or event streams) are very similar to lists or other collections. This means that we can use techniques for working with collections to process events. For example, you can filter out those clicks that appear outside a specific area, and only display a message when the user clicks inside an area. Or you can wait a specific period of time, and inform the user the number of valid clicks during this period. Similarly, you can capture a stream of stock ticks and only respond to those ticks that have changed for a specific range during a particular time window. All these can be done easily by using LINQ-query style operators provided by Rx. - -In this way, a function can take an event, process it, and then pass out the processed stream to an application. This gives you flexibility that is not available in the current programming model. Moreover, as Rx is performing all the plumbing work at the background for filtering, synchronizing, and transforming the data, your handler can just react to the data it receives and do something with it. This results in cleaner code that is easier to read and maintain. For more information on filtering, see Querying Observable Collections using LINQ Operators. - -## Manipulating Events - -Rx represents events as a collection of objects: e.g., a OnMouseMove event contains a collection of Point values. Due to the first-class object nature of observables, they can be passed around as function parameters and returns, or stored in a variable. - -This topic describes where you can download the Reactive Extensions (Rx) SDK. - -## To download Rx - -Reactive Extensions is available for different platforms such as C++, Javascript, .NET Framework 3.5, 4.0, 4.5, Silverlight 3 and 4, as well as Windows Phone 7 & 8\. You can download the libraries, as well as learn about their prerequisites at the [Rx MSDN Developer Center.][1] - -The following topic describes the various platforms for which you can develop solutions using Reactive Extensions. - -To get the latest release of Rx, as well as learn about its prerequisites, please visit the [Rx MSDN Developer Center][1]. - -## C++ - -The Reactive Extensions for C++ (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in C++. - -## Javascript - -Rx for Javascript (RxJS) allows you to use LINQ operators in JavaScript. It provides easy-to-use conversions from existing DOM, XmlHttpRequest (AJAX), and jQuery events to push-based observable collections, allowing users to seamlessly integrate Rx into their existing JavaScript-based websites. - -RxJS brings similar capabilities to client script and integrates with jQuery events (Rx.Observable.FromJQueryEvent). It also supports Script#. - -## Ruby - -Rx for Ruby (Rx.rb) allows you to use Linq operators to create push-based observable collections in Ruby. - -## Python - -RX for Python (Rx.py) allows you to use Linq operators in Python. Rx.py allows you to implement push-based observable collections, allowing users to seamlessly integrate Rx into their existing Python applications. - -## .NET Framework - -The core Rx interfaces, IObservable and IObserver, ship as part of .NET Framework 4. If you are running on .NET Framework 3.5 SP1, or if you want to take advantage of the LINQ operators implemented in Observable type, as well as many other features such as schedulers, you can download the Rx header-only library in the [Rx MSDN Developer Center][1]. - -## Silverlight - -Silverlight disallows you from making cross-threading calls, thus you cannot use a background thread to update the UI. Instead of writing verbose code using the Dispatcher.BeginInvoke call to explicitly execute code on the main UI thread, you can use the factory Observable.Start method provided by the Rx header-only library to invoke an action asynchronously. Cross-threading is taken care of transparently by Rx under the hood. - -You can also use the various Observable operator overloads that take in a Scheduler, and specify the System.Reactive.Concurrency.DispatcherScheduler to be used. - -## Windows Phone - -Windows Phone 7 ships with a version of the Reactive Extensions baked into the ROM of the device. For more information, see [Reactive Extensions for .NET Overview for Windows Phone][2]. Documentation for this version of the Reactive Extensions can be found in Windows Phone API library at [Microsoft.Phone.Reactive Namespace][3]. - -The [Rx MSDN Developer Center][1] also contains an updated version of Rx for WP7, which has new definitions in the System.Reactive.Linq namespace. Note that the new APIs will not clash with the library built in to the phone (nor do they replace the version in the ROM). For more information on the differences of these 2 versions, see this [Rx team blog post][4]. - -Rx is available for Windows Phone 8 as well as Windows Phone 7. A .NET portable library is available using Nuget that is useful for developing libraries that work on Windows Phone, Windows Store apps, and in classic Windows desktop or server applications. - -This section includes topics that explain how you use Rx to create and subscribe to sequences, bridge existing events and existing asynchronous patterns, as well as using schedulers. It also describes more advanced tasks such as implementing your own operators. - -### In This Section - -1. Exploring The Major Interfaces in Rx -2. Creating and Querying Event Streams -3. Subjects -6. Implementing your own operators for IObservable -7. Using Observable Providers - -This topic describes the major Reactive Extensions (Rx) interfaces used to represent observable sequences and subscribe to them. - -## Observable/Observer - -Rx exposes asynchronous and event-based data sources as push-based, observable sequences. This Observable class represents a data source that can be observed, meaning that it can send data to anyone who is interested. It maintains a list of dependent Observer implementations representing such interested listeners, and notifies them automatically of any state changes. - -As described in What is Rx, the other half of the push model is represented by the Observer class, which represents an observer who registers an interest through a subscription. Items are subsequently handed to the observer from the observable sequence to which it subscribes. - -In order to receive notifications from an observable collection, you use the subscribe method of Observable to hand it an Observer object. In return for this observer, the subscribe method returns a disposable object that acts as a handle for the subscription. This allows you to clean up the subscription after you are done. Calling dispose on this object detaches the observer from the source so that notifications are no longer delivered. As you can infer, in Rx you do not need to explicitly unsubscribe from an event. - -Observers support three publication events, reflected by the interfaces methods. OnNext can be called zero or more times, when the observable data source has data available. For example, an observable data source used for mouse move events can send out a Point object every time the mouse has moved. The other two methods are used to indicate completion or errors. - -The following lists the Observable/Observer definitions. - - namespace rxcpp { - template - struct Observer - { - virtual void OnNext(const T&) {}; - virtual void OnCompleted() {}; - virtual void OnError(const std::exception_ptr&) {}; - - virtual ~Observer() {} - }; - - template - struct Observable - { - virtual Disposable Subscribe(std::shared_ptr> observer) = 0; - virtual ~Observable() {} - }; - } - -Note that the OnError event returns an exception_ptr type. The example above shows passing the error to a handler function. - -You can treat the observable sequence (such as a sequence of mouse-over events) as if it were a normal collection. Thus you can write LINQ queries over the collection to do things like filtering, grouping, composing, etc. To make observable sequences more useful, the Rx header-only library provides many factory LINQ operators so that you do not need to implement any of these on your own. This will be covered in the Querying Observable Collections using LINQ Operators topic. - -### See Also - -Creating and Subscribing to Simple Observable Sequences Querying Observable Collections using LINQ Operators - -This section describes how you can create and subscribe to an observable sequence, convert an existing C++ event into a sequence and query it. - -### In This Section - -Creating and Subscribing to Simple Observable Sequences -Querying Observable Collections using LINQ Operators - -You do not need to implement the Observable interface manually to create an observable sequences. Similarly, you do not need to implement Observer either to subscribe to a sequence. By installing the Reactive Extension header-only library, you can take advantage of the Observable type which provides many LINQ operators for you to create a simple sequence with zero, one or more elements. In addition, Rx provides Subscribe methods that take various combinations of OnNext, OnError and OnCompleted handlers in terms of delegates. - -## Creating and subscribing to a simple sequence - -The following sample uses the range operator of the Observable type to create a simple observable collection of numbers. The observer subscribes to this collection using the Subscribe method of the Observable class, and provides actions that are delegates which handle OnNext, OnCompleted and OnError. - -The range operator has several overloads. In our example, it creates a sequence of integers that starts with x and produces y sequential numbers afterwards. - -As soon as the subscription happens, the values are sent to the observer. The OnNext delegate then prints out the values. - - auto values1 = rxcpp::Range(1, 10); - rxcpp::from(values1) - .for_each( - [](int p) { - cout }); - -When an observer subscribes to an observable sequence, the thread calling the subscribe method can be different from the thread in which the sequence runs till completion. Therefore, the subscribe call is asynchronous in that the caller is not blocked until the observation of the sequence completes. This will be covered in more details in the Using Schedulers topic. - -Notice that the subscribe method returns a Disposable, so that you can unsubscribe to a sequence and dispose of it easily. When you invoke the Dispose method on the observable sequence, the observer will stop listening to the observable for data. Normally, you do not need to explicitly call Dispose unless you need to unsubscribe early, or when the source observable sequence has a longer life span than the observer. Subscriptions in Rx are designed for fire-and-forget scenarios without the usage of a finalizer. When the Disposable instance is collected by the garbage collector, Rx does not automatically dispose of the subscription. However, note that the default behavior of the Observable operators is to dispose of the subscription as soon as possible (i.e, when an OnCompleted or OnError messages is published). - -In addition to creating an observable sequence from scratch, you can convert existing enumerators, C++ events and asynchronous patterns into observable sequences. The other topics in this section will show you how to do this. - -Notice that this topic only shows you a few operators that can create an observable sequence from scratch. To learn more about other LINQ operators, see Query Observable Collections using LINQ Operators. - -## Converting an Enumerable Collection to an Observable Sequence - -Using the Iterate operator, you can convert an array colection to an observable sequence and subscribe to it. - - std::array a={1, 2, 3}; - auto values1 = rxcpp::Iterate(a); - - rxcpp::from(values1) - .for_each( - [](int p) { - cout }); - - -### See Also - -Query Observable Collections using LINQ Operators - -We have converted existing C++ events into observable sequences to subscribe to them. In this topic, we will look at the first-class nature of observable sequences as Observable objects, in which generic LINQ operators are supplied by the Rx header-only library to manipulate these objects. Most operators take an observable sequence and perform some logic on it and output another observable sequence. In addition, as you can see from our code samples, you can even chain multiple operators on a source sequence to tweak the resulting sequence to your exact requirement. - -## Using Different Operators - -We have already used the Create and Generate operators in previous topics to create and return simple sequences. In this topic, we will use other LINQ operators of the Observable type so that you can filter, group and transform data. Such operators take observable sequence(s) as input, and produce observable sequence(s) as output. - -## Combining different sequences - -In this section, we will examine some of the operators that combine various observable sequences into a single observable sequence. Notice that data are not transformed when we combine sequences. - -In the following sample, we use the concat operator to combine two sequences into a single sequence and subscribe to it. - - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .select([](int prime) ->; std::tuple { return std::make_tuple("1:", prime);}) - .take(3); - - auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers - auto s2 = rxcpp::from(values2) - .subscribe_on(input2) - .select([](int prime) ->; std::tuple { return std::make_tuple("2:", prime);}) - .take(3); - - rxcpp::from(s1) - .concat(s2) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](const char* s, int p) { - cout })); - - -Notice that the resultant sequence is 1,2,3,1,2,3. This is because when you use the concat operator, the 2nd sequence (source2) will not be active until after the 1st sequence (source1) has finished pushing all its values. It is only after source1 has completed, then source2 will start to push values to the resultant sequence. The subscriber will then get all the values from the resultant sequence. - -Compare this with the merge operator. If you run the following sample code, you will get 1,1,2,2,3,3. This is because the two sequences are active at the same time and values are pushed out as they occur in the sources. The resultant sequence only completes when the last source sequence has finished pushing values. - -Notice that for Merge to work, all the source observable sequences need to be of the same type of Observable. The resultant sequence will be of the type Observable. If source1 produces an OnError in the middle of the sequence, then the resultant sequence will complete immediately. - - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .select([](int data) -> std::tuple { return std::make_tuple("1: ", data);}); - - auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers - rxcpp::from(values2) - .subscribe_on(input1) - .select([](int data) -> std::tuple { return std::make_tuple("2: ", data);}) - .merge(s1) - .take(6) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](const char* s, int p) { - cout })); - -Notice that for these combination operators to work, all the observable sequences need to be of the same type. - -This section describes the Subject type implemented by Reactive Extensions. It also describes various implementations of Subject which serves different purposes. - -### In This Section - -1. Using Subjects - -The Subject type implements both Observable and Observer, in the sense that it is both an observer and an observable. You can use a subject to subscribe all the observers, and then subscribe the subject to a backend data source. In this way, the subject can act as a proxy for a group of subscribers and a source. You can use subjects to implement a custom observable with caching, buffering and time shifting. In addition, you can use subjects to broadcast data to multiple subscribers. - -By default, subjects do not perform any synchronization across threads. They do not take a scheduler but rather assume that all serialization and grammatical correctness are handled by the caller of the subject. A subject simply broadcasts to all subscribed observers in the thread-safe list of subscribers. Doing so has the advantage of reducing overhead and improving performance. If, however, you want to synchronize outgoing calls to observers using a scheduler, you can use the Synchronize method to do so. - -## Different types of Subjects - -The Subject type in the Rx library is a basic implementation of the Subject interface (you can also implement the Subject interface to create your own subject types). There are other implementations of Subject that offer different functionalities. All of these types store some (or all of) values pushed to them via OnNext, and broadcast it back to its observers. This means that if you subscribe to any of these more than once (i.e. subscribe -> unsubscribe -> subscribe again), you will see at least one of the same value again. - -This section describes how you can use a scheduler to control when to start a sequence or subscribe to an event. - -The various Scheduler types provided by Rx are: - -ImmediateScheduler: Default scheduler, pushes notifications as they are recieved. - -EventLoopScheduler: Used when creating a separate thread for Rx sequences. - -A scheduler controls when a subscription starts and when notifications are published. It consists of three components. It is first a data structure. When you schedule for tasks to be completed, they are put into the scheduler for queueing based on priority or other criteria. It also offers an execution context which denotes where the task is executed (e.g., in the thread pool, current thread, or in another app domain). Lastly, it has a clock which provides a notion of time for itself (by accessing the Now property of a scheduler). Tasks being scheduled on a particular scheduler will adhere to the time denoted by that clock only. - -## Using Schedulers - -You may have already used schedulers in your Rx code without explicitly stating the type of schedulers to be used. This is because all Observable operators that deal with concurrency have multiple overloads. If you do not use the overload which takes a scheduler as an argument, Rx will pick a default scheduler by using the principle of least concurrency. This means that the scheduler which introduces the least amount of concurrency that satisfies the needs of the operator is chosen. For example, for operators returning an observable with a finite and small number of messages, Rx calls ImmediateScheduler. For operators returning a potentially large or infinite number of messages, CurrentThread is called. - -In the following example, the source observable sequences are each running in their own threads using EventLoopScheduler. - - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - auto values1 = rxcpp::Range(1); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .select([](int data) -> std::tuple { return std::make_tuple("1:", data);}) - .take(3); - - auto values2 = rxcpp::Range(1); // infinite (until overflow) stream of integers - auto s2 = rxcpp::from(values2) - .subscribe_on(input2) - .select([](int data) -> std::tuple { return std::make_tuple("2:", data);}) - .take(3); - - rxcpp::from(s1) - .concat(s2) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](const char* s, int p) { - cout })); - - -This will queue up on the observer quickly. We can improve this code by using the observe_on operator, which allows you to specify the context that you want to use to send pushed notifications (OnNext) to observers. By default, the observe_on operator ensures that OnNext will be called as many times as possible on the current thread. You can use its overloads and redirect the OnNext outputs to a different context. In addition, you can use the subscribe_on operator to return a proxy observable that delegates actions to a specific scheduler. For example, for a UI-intensive application, you can delegate all background operations to be performed on a scheduler running in the background by using subscribe_on and passing to it a Concurrency.EventLoopScheduler. - -You should also note that by using the observe_on operator, an action is scheduled for each message that comes through the original observable sequence. This potentially changes timing information as well as puts additional stress on the system. If you have a query that composes various observable sequences running on many different execution contexts, and you are doing filtering in the query, it is best to place observe_on later in the query. This is because a query will potentially filter out a lot of messages, and placing the observe_on operator earlier in the query would do extra work on messages that would be filtered out anyway. Calling the observe_on operator at the end of the query will create the least performance impact. - -You can extend Rx by adding new operators for operations that are not provided by the LINQ library, or by creating your own implementation of standard query operators to improve readability and performance. Writing a customized version of a standard LINQ operator is useful when you want to operate with in-memory objects and when the intended customization does not require a comprehensive view of the query. - -## Creating New Operators - -LINQ offers a full set of operators that cover most of the possible operations on a set of entities. However, you might need an operator to add a particular semantic meaning to your queryespecially if you can reuse that same operator several times in your code. - -By reusing existing LINQ operators when you build a new one, you can take advantage of the existing performance or exception handling capabilities implemented in the Rx libraries. - -When writing a custom operator, it is good practice not to leave any disposables unused; otherwise, you may find that resources could actually be leaked and cancellation may not work correctly. - -## Customizing Existing Operators - -Adding new operators to LINQ is a way to extend its capabilities. However, you can also improve code readability by wrapping existing operators into more specialized and meaningful ones. - - -http://msdn.microsoft.com/en-us/data/gg577609 -http://msdn.microsoft.com/en-us/library/ff431792(VS.92).aspx -http://msdn.microsoft.com/en-us/library/ff707857(v=VS.92).aspx -http://blogs.msdn.com/b/rxteam/archive/2010/10/28/rx-for-windows-phone-7.aspx - - +You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. \ No newline at end of file -- GitLab From 06431b9a492fec17ad539416464c54a6f05c5447 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 27 Sep 2013 07:12:53 -0700 Subject: [PATCH 079/782] fix bug when using where on an empty collection --- Ix/CPP/src/cpplinq/linq_where.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Ix/CPP/src/cpplinq/linq_where.hpp b/Ix/CPP/src/cpplinq/linq_where.hpp index 4f66ba7..9b3d936 100644 --- a/Ix/CPP/src/cpplinq/linq_where.hpp +++ b/Ix/CPP/src/cpplinq/linq_where.hpp @@ -24,7 +24,7 @@ namespace cpplinq cursor(const inner_cursor& cur, const Predicate& p) : cur(cur), pred(p) { - if (!pred(cur.get())) { + if (!cur.empty() && !pred(cur.get())) { this->inc(); } } -- GitLab From c33d2725398cbbf13154e74e1c8fb910df536b90 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 27 Sep 2013 07:14:29 -0700 Subject: [PATCH 080/782] fixed name-hiding bug and Zip end-condition bug --- Rx/CPP/src/cpprx/rx-operators.hpp | 78 ++++++++++--------------------- 1 file changed, 24 insertions(+), 54 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 77de860..fd68c06 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -920,7 +920,7 @@ namespace rxcpp { if (!scheduler) { - scheduler = std::make_shared(); + this->scheduler = std::make_shared(); } } }; @@ -1838,21 +1838,18 @@ namespace rxcpp namespace detail{ template struct ZipSubscriber { - typedef typename std::tuple_element::type::value_type Item; + typedef typename std::tuple_element::type::second_type::value_type Item; typedef std::shared_ptr> ResultObserver; struct Next { - std::unique_lock& guard; std::shared_ptr state; const ResultObserver& observer; const ComposableDisposable& cd; explicit Next( - std::unique_lock& guard, std::shared_ptr state, const ResultObserver& observer, const ComposableDisposable& cd) - : guard(guard) - , state(std::move(state)) + : state(std::move(state)) , observer(observer) , cd(cd) { } @@ -1860,15 +1857,15 @@ namespace rxcpp template void operator()(ZipQueue&... queue) { // build array of bool that we can iterate to detect empty queues - bool empties[] = {queue.empty()...}; + bool empties[] = {queue.second.empty()...}; if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { // all queues have an item. // // copy front of each queue - auto args = std::make_tuple(queue.front()...); + auto args = std::make_tuple(queue.second.front()...); // cause side-effect of pop on each queue - std::make_tuple((queue.pop(), true)...); + std::make_tuple((queue.second.pop(), true)...); typedef decltype(util::tuple_dispatch(state->selector, args)) U; util::maybe result; @@ -1878,24 +1875,14 @@ namespace rxcpp observer->OnError(std::current_exception()); } if (!!result) { - ++state->pending; - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(*result.get())); - } - --state->pending; + observer->OnNext(std::move(*result.get())); } } // build new array to check for any empty queue - bool post_empties[] = {queue.empty()...}; - if (state->completed && state->pending == 0 && - std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { + bool post_empties[] = {queue.first && queue.second.empty()...}; + if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { // at least one queue is empty and at least one of the sources has completed. // it is time to stop. - - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); observer->OnCompleted(); cd.Dispose(); } @@ -1904,15 +1891,15 @@ namespace rxcpp template void operator()(ZipQueue1& queue1, ZipQueue2& queue2) { // build array of bool that we can iterate to detect empty queues - bool empties[] = {queue1.empty(), queue2.empty()}; + bool empties[] = {queue1.second.empty(), queue2.second.empty()}; if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { // all queues have an item. // // copy front of each queue - auto args = std::make_tuple(queue1.front(), queue2.front()); + auto args = std::make_tuple(queue1.second.front(), queue2.second.front()); - queue1.pop(); - queue2.pop(); + queue1.second.pop(); + queue2.second.pop(); typedef decltype(util::tuple_dispatch(state->selector, args)) U; util::maybe result; @@ -1922,24 +1909,14 @@ namespace rxcpp observer->OnError(std::current_exception()); } if (!!result) { - ++state->pending; - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(*result.get())); - } - --state->pending; + observer->OnNext(std::move(*result.get())); } } // build new array to check for any empty queue - bool post_empties[] = {queue1.empty(), queue2.empty()}; - if (state->completed && state->pending == 0 && - std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { + bool post_empties[] = {queue1.first && queue1.second.empty(), queue2.first && queue2.second.empty()}; + if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { // at least one queue is empty and at least one of the sources has completed. // it is time to stop. - - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); observer->OnCompleted(); cd.Dispose(); } @@ -1957,21 +1934,22 @@ namespace rxcpp [=](const Item& element) { std::unique_lock guard(state->lock); - std::get(state->queues).push(element); - Next next(guard, state, observer, cd); + std::get(state->queues).second.push(element); + Next next(state, observer, cd); util::tuple_dispatch(next, state->queues); }, // on completed [=] { std::unique_lock guard(state->lock); - state->completed = true; - Next next(guard, state, observer, cd); + std::get(state->queues).first = true; + Next next(state, observer, cd); util::tuple_dispatch(next, state->queues); }, // on error [=](const std::exception_ptr& error) { + std::unique_lock guard(state->lock); observer->OnError(error); cd.Dispose(); })); @@ -1998,7 +1976,7 @@ namespace rxcpp { typedef typename std::result_of::type result_type; typedef std::tuple>...> Sources; - typedef std::tuple...> Queues; + typedef std::tuple>...> Queues; struct State { typedef Queues Queues; typedef Sources Sources; @@ -2006,13 +1984,9 @@ namespace rxcpp typedef std::tuple_size SourcesSize; explicit State(S selector) : selector(std::move(selector)) - , pending(0) - , completed(false) {} std::mutex lock; S selector; - size_t pending; - bool completed; Queues queues; }; Sources sources(source...); @@ -2037,7 +2011,7 @@ namespace rxcpp { typedef typename std::result_of::type result_type; typedef std::tuple>, std::shared_ptr>> Sources; - typedef std::tuple, std::queue> Queues; + typedef std::tuple>, std::pair>> Queues; struct State { typedef Queues Queues; typedef Sources Sources; @@ -2045,13 +2019,9 @@ namespace rxcpp typedef std::tuple_size SourcesSize; explicit State(S selector) : selector(std::move(selector)) - , pending(0) - , completed(false) {} std::mutex lock; S selector; - size_t pending; - bool completed; Queues queues; }; Sources sources(source1, source2); @@ -2774,7 +2744,7 @@ namespace rxcpp template - const std::shared_ptr> ToStdCollection( + std::shared_ptr> ToStdCollection( const std::shared_ptr>& source ) { -- GitLab From a05cc5a0543340daa642aba7dcddaeee7bdc8d2a Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sat, 28 Sep 2013 21:25:20 -0700 Subject: [PATCH 081/782] adding random operator --- Rx/CPP/src/cpprx/rx-operators.hpp | 57 +++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index fd68c06..e70e460 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -1067,6 +1067,63 @@ namespace rxcpp }); } + // + // std::mt19937 twister; + // std::uniform_int_distribution xDistribution(0, xExtent - 1); + // auto xSource = Random(twister, xDistribution, [](std::mt19937& e){ + // e.seed(std::random_device()()); + // }); + // + template + std::shared_ptr> Random( + Engine e, + Distribution d, + Seeder s, + Scheduler::shared scheduler = nullptr) + { + typedef typename Distribution::result_type T; + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Engine e; + Distribution d; + T step() + { + return d(e); + } + }; + auto state = std::make_shared(); + state->cancel = false; + state->e = e; + state->d = d; + + // allow the seed to be set + s(state->e); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + if (state->cancel) + return Disposable::Empty(); + + observer->OnNext(state->step()); + return s->Schedule(std::move(self)); + }))); + + return cd; + }); + } + inline std::shared_ptr> Interval( Scheduler::clock::duration due, Scheduler::shared scheduler) -- GitLab From 238f86c998f1b1be77521256e500cbf0834f3950 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 6 Nov 2013 00:05:00 -0800 Subject: [PATCH 082/782] Fixes Scan adds Empty --- Rx/CPP/src/cpprx/rx-operators.hpp | 104 +++++++++++++++++++++++++++--- Rx/CPP/src/cpprx/rx.hpp | 5 ++ Rx/CPP/testbench/testbench.cpp | 55 ++++++++++++++++ 3 files changed, 154 insertions(+), 10 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index e70e460..324652f 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -869,6 +869,66 @@ namespace rxcpp } }; + namespace detail + { + template + class EmptyObservable : public Producer, T> + { + typedef std::shared_ptr> Parent; + Scheduler::shared scheduler; + + class _ : public Sink<_, T> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + auto local = parent; + auto that = this->shared_from_this(); + return parent->scheduler->Schedule( + [=](Scheduler::shared) -> Disposable { + that->SinkBase::observer->OnCompleted(); + that->SinkBase::Dispose(); + return Disposable::Empty(); + }); + } + }; + + typedef Producer, T> ProducerBase; + public: + + EmptyObservable(Scheduler::shared scheduler) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + scheduler(scheduler) + { + if (!scheduler) + { + this->scheduler = std::make_shared(); + } + } + }; + } + template + std::shared_ptr> Empty( + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(scheduler)); + } namespace detail { @@ -916,7 +976,8 @@ namespace rxcpp setSink(sink->GetDisposable()); return sink->Run(); }), - value(value) + value(value), + scheduler(scheduler) { if (!scheduler) { @@ -926,7 +987,7 @@ namespace rxcpp }; } template - const std::shared_ptr> Return( + std::shared_ptr> Return( T value, Scheduler::shared scheduler = nullptr ) @@ -981,11 +1042,12 @@ namespace rxcpp setSink(sink->GetDisposable()); return sink->Run(); }), - exception(exception) + exception(exception), + scheduler(scheduler) { if (!scheduler) { - scheduler = std::make_shared(); + this->scheduler = std::make_shared(); } } }; @@ -2465,12 +2527,14 @@ namespace rxcpp public: typedef std::function Accumulator; + typedef std::function(T)> Seeder; private: Source source; - A seed; + util::maybe seed; Accumulator accumulator; + Seeder seeder; class _ : public Sink<_, A>, public Observer { @@ -2496,7 +2560,7 @@ namespace rxcpp } else { - accumulation.set(parent->accumulator(parent->seed, t)); + accumulation.set(!!parent->seed ? parent->accumulator(*parent->seed.get(), t) : *parent->seeder(t).get()); } } catch (...) @@ -2509,6 +2573,9 @@ namespace rxcpp } virtual void OnCompleted() { + if (!accumulation && !!parent->seed) { + SinkBase::observer->OnNext(*parent->seed.get()); + } SinkBase::observer->OnCompleted(); SinkBase::Dispose(); } @@ -2522,7 +2589,7 @@ namespace rxcpp typedef Producer ProducerBase; public: - ScanObservable(Source source, A seed, Accumulator accumulator) : + ScanObservable(Source source, util::maybe seed, Accumulator accumulator, Seeder seeder) : ProducerBase([this](Parent parent, std::shared_ptr < Observer < A >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable { auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); @@ -2531,19 +2598,36 @@ namespace rxcpp }), source(std::move(source)), seed(std::move(seed)), - accumulator(std::move(accumulator)) + accumulator(std::move(accumulator)), + seeder(std::move(seeder)) { } }; } template - const std::shared_ptr> Scan( + std::shared_ptr> Scan( const std::shared_ptr>& source, A seed, typename detail::ScanObservable::Accumulator accumulator ) { - return std::make_shared>(std::move(source), std::move(seed), std::move(accumulator)); + return std::make_shared>( + std::move(source), + util::maybe(std::move(seed)), + std::move(accumulator), + [](T) -> util::maybe {std::abort(); return util::maybe();}); + } + template + std::shared_ptr> Scan( + const std::shared_ptr>& source, + typename detail::ScanObservable::Accumulator accumulator + ) + { + return std::make_shared>( + std::move(source), + util::maybe(), + std::move(accumulator), + [](T t) -> util::maybe {return util::maybe(t);}); } template diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 54ae133..3835a3c 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -283,6 +283,11 @@ namespace detail { -> decltype(from(Scan(obj, seed, accumulator))) { return from(Scan(obj, seed, accumulator)); } + template + auto scan(A accumulator) + -> decltype(from(Scan(obj, accumulator))) { + return from(Scan(obj, accumulator)); + } template auto take(Integral n) -> decltype(from(Take(obj, n))) { diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 6122fd7..6aaee53 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -59,6 +59,59 @@ void PrintPrimes(int n) })); } +void Scan() +{ + int test = 0; + auto next = [&](int i) { + cout << "next " << test << ":" << i << endl; + }; + auto complete = [&]() { + cout << "completed " << test << endl; + }; + auto error = [&](std::exception_ptr e) { + try { + std::rethrow_exception(e); + } + catch(std::exception ex) { + cout << ex.what() << endl; + } + }; + + auto input = std::make_shared(); + + auto add = [](int x, int y){return x + y;}; + + // Usage + auto obs1 = rxcpp::from(rxcpp::Empty(input)).scan(add); + auto obs2 = rxcpp::from(rxcpp::Empty(input)).scan(0, add); + + auto obs3 = rxcpp::from(rxcpp::Range(1, 3, 1, input)).scan(add); + auto obs4 = rxcpp::from(rxcpp::Range(1, 3, 1, input)).scan(0, add); + + test = 1; + obs1.subscribe(next, complete, error); + // => completed 1 + + test = 2; + obs2.subscribe(next, complete, error); + // => next 2:0 + // => completed 2 + + test = 3; + obs3.subscribe(next, complete, error); + // => next 3:1 + // => next 3:3 + // => next 3:6 + // => completed 3 + + test = 4; + obs4.subscribe(next, complete, error); + // => next 4:1 + // => next 4:3 + // => next 4:6 + // => completed 4 +} + void Concat(int n) { auto input1 = std::make_shared(); @@ -493,6 +546,8 @@ int main(int argc, char* argv[]) innerScheduler(); innerScheduler(); + Scan(); + run(); } catch (exception& e) { -- GitLab From 35de7d7daf1ccd7125d655127ab3537b7401b96f Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 11:29:58 -0800 Subject: [PATCH 083/782] moved Empty to separate header --- Rx/CPP/src/cpprx/operators/Empty.hpp | 73 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-includes.hpp | 2 + Rx/CPP/src/cpprx/rx-operators.hpp | 64 ++---------------------- 3 files changed, 80 insertions(+), 59 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Empty.hpp diff --git a/Rx/CPP/src/cpprx/operators/Empty.hpp b/Rx/CPP/src/cpprx/operators/Empty.hpp new file mode 100644 index 0000000..6dfb448 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Empty.hpp @@ -0,0 +1,73 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(CPPRX_RX_OPERATORS_EMPTY_HPP) +#define CPPRX_RX_OPERATORS_EMPTY_HPP + +namespace rxcpp +{ + + namespace detail + { + template + class EmptyObservable : public Producer, T> + { + typedef std::shared_ptr> Parent; + Scheduler::shared scheduler; + + class _ : public Sink<_, T> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + auto local = parent; + auto that = this->shared_from_this(); + return parent->scheduler->Schedule( + [=](Scheduler::shared) -> Disposable { + that->SinkBase::observer->OnCompleted(); + that->SinkBase::Dispose(); + return Disposable::Empty(); + }); + } + }; + + typedef Producer, T> ProducerBase; + public: + + EmptyObservable(Scheduler::shared scheduler) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + scheduler(scheduler) + { + if (!scheduler) + { + this->scheduler = std::make_shared(); + } + } + }; + } + template + std::shared_ptr> Empty( + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(scheduler)); + } +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index d8dc7c1..743a86f 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -10,6 +10,8 @@ #undef min #undef max +#include + #include #include #include diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 324652f..c44e02c 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -868,67 +868,13 @@ namespace rxcpp return subject->Subscribe(observer); } }; +} - namespace detail - { - template - class EmptyObservable : public Producer, T> - { - typedef std::shared_ptr> Parent; - Scheduler::shared scheduler; - - class _ : public Sink<_, T> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } +#include "operators/empty.hpp" - Disposable Run() - { - auto local = parent; - auto that = this->shared_from_this(); - return parent->scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - that->SinkBase::observer->OnCompleted(); - that->SinkBase::Dispose(); - return Disposable::Empty(); - }); - } - }; - - typedef Producer, T> ProducerBase; - public: +namespace rxcpp +{ - EmptyObservable(Scheduler::shared scheduler) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - scheduler(scheduler) - { - if (!scheduler) - { - this->scheduler = std::make_shared(); - } - } - }; - } - template - std::shared_ptr> Empty( - Scheduler::shared scheduler = nullptr - ) - { - return std::make_shared>(std::move(scheduler)); - } namespace detail { @@ -2615,7 +2561,7 @@ namespace rxcpp std::move(source), util::maybe(std::move(seed)), std::move(accumulator), - [](T) -> util::maybe {std::abort(); return util::maybe();}); + [](T) -> util::maybe {abort(); return util::maybe();}); } template std::shared_ptr> Scan( -- GitLab From 0b4df348fb25eeca76e81784834d0cf9093bb91b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 11:39:16 -0800 Subject: [PATCH 084/782] move Return to separate header --- Rx/CPP/src/cpprx/operators/Return.hpp | 77 +++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 69 +----------------------- 2 files changed, 79 insertions(+), 67 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Return.hpp diff --git a/Rx/CPP/src/cpprx/operators/Return.hpp b/Rx/CPP/src/cpprx/operators/Return.hpp new file mode 100644 index 0000000..bb1e129 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Return.hpp @@ -0,0 +1,77 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(CPPRX_RX_OPERATORS_RETURN_HPP) +#define CPPRX_RX_OPERATORS_RETURN_HPP + +namespace rxcpp +{ + + namespace detail + { + template + class ReturnObservable : public Producer, T> + { + typedef std::shared_ptr> Parent; + T value; + Scheduler::shared scheduler; + + class _ : public Sink<_, T> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + auto local = parent; + auto that = this->shared_from_this(); + return parent->scheduler->Schedule( + [=](Scheduler::shared) -> Disposable { + that->SinkBase::observer->OnNext(local->value); + that->SinkBase::observer->OnCompleted(); + that->SinkBase::Dispose(); + return Disposable::Empty(); + }); + } + }; + + typedef Producer, T> ProducerBase; + public: + + ReturnObservable(T value, Scheduler::shared scheduler) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + value(value), + scheduler(scheduler) + { + if (!scheduler) + { + this->scheduler = std::make_shared(); + } + } + }; + } + template + std::shared_ptr> Return( + T value, + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(value), std::move(scheduler)); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index c44e02c..411b720 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -870,77 +870,12 @@ namespace rxcpp }; } -#include "operators/empty.hpp" +#include "operators/Empty.hpp" +#include "operators/Return.hpp" namespace rxcpp { - - namespace detail - { - template - class ReturnObservable : public Producer, T> - { - typedef std::shared_ptr> Parent; - T value; - Scheduler::shared scheduler; - - class _ : public Sink<_, T> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - auto local = parent; - auto that = this->shared_from_this(); - return parent->scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - that->SinkBase::observer->OnNext(local->value); - that->SinkBase::observer->OnCompleted(); - that->SinkBase::Dispose(); - return Disposable::Empty(); - }); - } - }; - - typedef Producer, T> ProducerBase; - public: - - ReturnObservable(T value, Scheduler::shared scheduler) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - value(value), - scheduler(scheduler) - { - if (!scheduler) - { - this->scheduler = std::make_shared(); - } - } - }; - } - template - std::shared_ptr> Return( - T value, - Scheduler::shared scheduler = nullptr - ) - { - return std::make_shared>(std::move(value), std::move(scheduler)); - } - namespace detail { template -- GitLab From a3bedef1715f5d9069c3c0c2cc3e1f31957ed531 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:27:00 -0800 Subject: [PATCH 085/782] recursive reference to help editor --- Rx/CPP/src/cpprx/operators/Empty.hpp | 1 + Rx/CPP/src/cpprx/operators/Return.hpp | 1 + 2 files changed, 2 insertions(+) diff --git a/Rx/CPP/src/cpprx/operators/Empty.hpp b/Rx/CPP/src/cpprx/operators/Empty.hpp index 6dfb448..09466ca 100644 --- a/Rx/CPP/src/cpprx/operators/Empty.hpp +++ b/Rx/CPP/src/cpprx/operators/Empty.hpp @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. #pragma once +#include "../rx-operators.hpp" #if !defined(CPPRX_RX_OPERATORS_EMPTY_HPP) #define CPPRX_RX_OPERATORS_EMPTY_HPP diff --git a/Rx/CPP/src/cpprx/operators/Return.hpp b/Rx/CPP/src/cpprx/operators/Return.hpp index bb1e129..cb97075 100644 --- a/Rx/CPP/src/cpprx/operators/Return.hpp +++ b/Rx/CPP/src/cpprx/operators/Return.hpp @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. #pragma once +#include "../rx-operators.hpp" #if !defined(CPPRX_RX_OPERATORS_RETURN_HPP) #define CPPRX_RX_OPERATORS_RETURN_HPP -- GitLab From a7759e48e727c23f5cc13487e6dd1136c48f5567 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:27:16 -0800 Subject: [PATCH 086/782] move Throw to separate header --- Rx/CPP/src/cpprx/operators/Throw.hpp | 79 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 66 +---------------------- 2 files changed, 80 insertions(+), 65 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Throw.hpp diff --git a/Rx/CPP/src/cpprx/operators/Throw.hpp b/Rx/CPP/src/cpprx/operators/Throw.hpp new file mode 100644 index 0000000..df94880 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Throw.hpp @@ -0,0 +1,79 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_THROW_HPP) +#define CPPRX_RX_OPERATORS_THROW_HPP + +namespace rxcpp +{ + + namespace detail + { + template + class ThrowObservable : public Producer, T> + { + typedef ThrowObservable This; + typedef std::shared_ptr Parent; + + std::exception_ptr exception; + Scheduler::shared scheduler; + + class _ : public Sink<_, T> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + auto local = parent; + auto that = this->shared_from_this(); + return parent->scheduler->Schedule( + [=](Scheduler::shared) -> Disposable { + that->SinkBase::observer->OnError(local->exception); + that->SinkBase::Dispose(); + return Disposable::Empty(); + }); + } + }; + + typedef Producer ProducerBase; + public: + + ThrowObservable(std::exception_ptr exception, Scheduler::shared scheduler) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + exception(exception), + scheduler(scheduler) + { + if (!scheduler) + { + this->scheduler = std::make_shared(); + } + } + }; + } + template + const std::shared_ptr> Throw( + std::exception_ptr exception, + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(exception), std::move(scheduler)); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 411b720..5ba0c91 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -872,75 +872,11 @@ namespace rxcpp #include "operators/Empty.hpp" #include "operators/Return.hpp" +#include "operators/Throw.hpp" namespace rxcpp { - namespace detail - { - template - class ThrowObservable : public Producer, T> - { - typedef ThrowObservable This; - typedef std::shared_ptr Parent; - - std::exception_ptr exception; - Scheduler::shared scheduler; - - class _ : public Sink<_, T> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - auto local = parent; - auto that = this->shared_from_this(); - return parent->scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - that->SinkBase::observer->OnError(local->exception); - that->SinkBase::Dispose(); - return Disposable::Empty(); - }); - } - }; - - typedef Producer ProducerBase; - public: - - ThrowObservable(std::exception_ptr exception, Scheduler::shared scheduler) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - exception(exception), - scheduler(scheduler) - { - if (!scheduler) - { - this->scheduler = std::make_shared(); - } - } - }; - } - template - const std::shared_ptr> Throw( - std::exception_ptr exception, - Scheduler::shared scheduler = nullptr - ) - { - return std::make_shared>(std::move(exception), std::move(scheduler)); - } template struct fix0_thunk { -- GitLab From 48a58b94e2463cd23d5379fff81ec44c5ee5ed7b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:30:08 -0800 Subject: [PATCH 087/782] move Range to separate header --- Rx/CPP/src/cpprx/operators/Range.hpp | 65 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 64 +++------------------------ 2 files changed, 72 insertions(+), 57 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Range.hpp diff --git a/Rx/CPP/src/cpprx/operators/Range.hpp b/Rx/CPP/src/cpprx/operators/Range.hpp new file mode 100644 index 0000000..2e346cc --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Range.hpp @@ -0,0 +1,65 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_RANGE_HPP) +#define CPPRX_RX_OPERATORS_RANGE_HPP + +namespace rxcpp +{ + + + template + auto Range( + Integral start, Integral end = std::numeric_limits::max(), Integral step = 1, + Scheduler::shared scheduler = nullptr) + -> std::shared_ptr> + { + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Integral i; + Integral rem; + }; + auto state = std::make_shared(); + state->cancel = false; + state->i = start; + state->rem = ((end - start) + step) / step; + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + if (state->cancel) + return Disposable::Empty(); + + if (!state->rem) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(state->i); + --state->rem; + state->i += step; + return s->Schedule(std::move(self)); + } + return Disposable::Empty(); + }))); + + return cd; + }); + } +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 5ba0c91..c3ce2c5 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -868,15 +868,6 @@ namespace rxcpp return subject->Subscribe(observer); } }; -} - -#include "operators/Empty.hpp" -#include "operators/Return.hpp" -#include "operators/Throw.hpp" - -namespace rxcpp -{ - template struct fix0_thunk { @@ -894,57 +885,16 @@ namespace rxcpp { return fix0_thunk(std::move(f)); } +} - template - auto Range( - Integral start, Integral end = std::numeric_limits::max(), Integral step = 1, - Scheduler::shared scheduler = nullptr) - -> std::shared_ptr> - { - if (!scheduler) {scheduler = std::make_shared();} - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Integral i; - Integral rem; - }; - auto state = std::make_shared(); - state->cancel = false; - state->i = start; - state->rem = ((end - start) + step) / step; - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - state->cancel = true; - })); - - cd.Add(scheduler->Schedule( - fix0([=](Scheduler::shared s, std::function self) -> Disposable - { - if (state->cancel) - return Disposable::Empty(); +#include "operators/Empty.hpp" +#include "operators/Return.hpp" +#include "operators/Throw.hpp" +#include "operators/Range.hpp" - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - state->i += step; - return s->Schedule(std::move(self)); - } - return Disposable::Empty(); - }))); +namespace rxcpp +{ - return cd; - }); - } // // std::mt19937 twister; -- GitLab From 22a97d5b1755c8db5d4c75b5822bf9ba0600410d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:32:39 -0800 Subject: [PATCH 088/782] move Random to separate header --- Rx/CPP/src/cpprx/operators/Random.hpp | 70 +++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 58 +--------------------- 2 files changed, 71 insertions(+), 57 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Random.hpp diff --git a/Rx/CPP/src/cpprx/operators/Random.hpp b/Rx/CPP/src/cpprx/operators/Random.hpp new file mode 100644 index 0000000..741acb8 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Random.hpp @@ -0,0 +1,70 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_RANDOM_HPP) +#define CPPRX_RX_OPERATORS_RANDOM_HPP + +namespace rxcpp +{ + + // + // std::mt19937 twister; + // std::uniform_int_distribution xDistribution(0, xExtent - 1); + // auto xSource = Random(twister, xDistribution, [](std::mt19937& e){ + // e.seed(std::random_device()()); + // }); + // + template + std::shared_ptr> Random( + Engine e, + Distribution d, + Seeder s, + Scheduler::shared scheduler = nullptr) + { + typedef typename Distribution::result_type T; + if (!scheduler) {scheduler = std::make_shared();} + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + bool cancel; + Engine e; + Distribution d; + T step() + { + return d(e); + } + }; + auto state = std::make_shared(); + state->cancel = false; + state->e = e; + state->d = d; + + // allow the seed to be set + s(state->e); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + if (state->cancel) + return Disposable::Empty(); + + observer->OnNext(state->step()); + return s->Schedule(std::move(self)); + }))); + + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index c3ce2c5..9d5eca0 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -891,68 +891,12 @@ namespace rxcpp #include "operators/Return.hpp" #include "operators/Throw.hpp" #include "operators/Range.hpp" +#include "operators/Random.hpp" namespace rxcpp { - // - // std::mt19937 twister; - // std::uniform_int_distribution xDistribution(0, xExtent - 1); - // auto xSource = Random(twister, xDistribution, [](std::mt19937& e){ - // e.seed(std::random_device()()); - // }); - // - template - std::shared_ptr> Random( - Engine e, - Distribution d, - Seeder s, - Scheduler::shared scheduler = nullptr) - { - typedef typename Distribution::result_type T; - if (!scheduler) {scheduler = std::make_shared();} - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Engine e; - Distribution d; - T step() - { - return d(e); - } - }; - auto state = std::make_shared(); - state->cancel = false; - state->e = e; - state->d = d; - - // allow the seed to be set - s(state->e); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - state->cancel = true; - })); - - cd.Add(scheduler->Schedule( - fix0([=](Scheduler::shared s, std::function self) -> Disposable - { - if (state->cancel) - return Disposable::Empty(); - - observer->OnNext(state->step()); - return s->Schedule(std::move(self)); - }))); - - return cd; - }); - } - inline std::shared_ptr> Interval( Scheduler::clock::duration due, Scheduler::shared scheduler) -- GitLab From 824301e9940c1a85cc2623bf02075e9c8969a0b5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:41:02 -0800 Subject: [PATCH 089/782] move Interval to separate header --- Rx/CPP/src/cpprx/operators/Interval.hpp | 62 +++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 52 +-------------------- 2 files changed, 64 insertions(+), 50 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Interval.hpp diff --git a/Rx/CPP/src/cpprx/operators/Interval.hpp b/Rx/CPP/src/cpprx/operators/Interval.hpp new file mode 100644 index 0000000..cd5a3e9 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Interval.hpp @@ -0,0 +1,62 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_INTERVAL_HPP) +#define CPPRX_RX_OPERATORS_INTERVAL_HPP + +namespace rxcpp +{ + + inline std::shared_ptr> Interval( + Scheduler::clock::duration due, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State : public std::enable_shared_from_this { + State(Scheduler::clock::duration due, + Scheduler::clock::time_point last, + std::shared_ptr> observer) : due(due), last(last), cursor(0), observer(observer) { + cd.Add(sd);} + + Scheduler::clock::duration due; + Scheduler::clock::time_point last; + size_t cursor; + std::shared_ptr> observer; + ComposableDisposable cd; + SerialDisposable sd; + + void Tick(Scheduler::shared s){ + observer->OnNext(cursor); + last += due; + ++cursor; + auto keepAlive = this->shared_from_this(); + sd.Set(s->Schedule( + last, + [this, keepAlive] (Scheduler::shared s) -> Disposable { + Tick(s); + return Disposable::Empty(); + } + )); + } + }; + auto state = std::make_shared(due, scheduler->Now(), observer); + + state->last += state->due; + state->sd.Set(scheduler->Schedule( + state->last, + [=] (Scheduler::shared s) -> Disposable { + state->Tick(s); + return Disposable::Empty(); + } + )); + return state->cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 9d5eca0..3330fc4 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -892,60 +892,11 @@ namespace rxcpp #include "operators/Throw.hpp" #include "operators/Range.hpp" #include "operators/Random.hpp" +#include "operators/Interval.hpp" namespace rxcpp { - - inline std::shared_ptr> Interval( - Scheduler::clock::duration due, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State : public std::enable_shared_from_this { - State(Scheduler::clock::duration due, - Scheduler::clock::time_point last, - std::shared_ptr> observer) : due(due), last(last), cursor(0), observer(observer) { - cd.Add(sd);} - - Scheduler::clock::duration due; - Scheduler::clock::time_point last; - size_t cursor; - std::shared_ptr> observer; - ComposableDisposable cd; - SerialDisposable sd; - - void Tick(Scheduler::shared s){ - observer->OnNext(cursor); - last += due; - ++cursor; - auto keepAlive = this->shared_from_this(); - sd.Set(s->Schedule( - last, - [this, keepAlive] (Scheduler::shared s) -> Disposable { - Tick(s); - return Disposable::Empty(); - } - )); - } - }; - auto state = std::make_shared(due, scheduler->Now(), observer); - - state->last += state->due; - state->sd.Set(scheduler->Schedule( - state->last, - [=] (Scheduler::shared s) -> Disposable { - state->Tick(s); - return Disposable::Empty(); - } - )); - return state->cd; - }); - } - using std::begin; using std::end; template @@ -1006,6 +957,7 @@ namespace rxcpp }); } + namespace detail { template -- GitLab From eb73b0ef0d0361c2abbbcba66a565be2ca819e52 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:41:55 -0800 Subject: [PATCH 090/782] move Iterate to separate header --- Rx/CPP/src/cpprx/operators/Iterate.hpp | 73 ++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 62 +--------------------- 2 files changed, 74 insertions(+), 61 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Iterate.hpp diff --git a/Rx/CPP/src/cpprx/operators/Iterate.hpp b/Rx/CPP/src/cpprx/operators/Iterate.hpp new file mode 100644 index 0000000..1ccca10 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Iterate.hpp @@ -0,0 +1,73 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_ITERATE_HPP) +#define CPPRX_RX_OPERATORS_ITERATE_HPP + +namespace rxcpp +{ + + using std::begin; + using std::end; + template + auto Iterate( + Range r, + Scheduler::shared scheduler = nullptr) + -> std::shared_ptr::type>> + { + typedef decltype(begin(r)) It; + typedef typename std::decay::type T; + + if (!scheduler) {scheduler = std::make_shared();} + auto range = std::make_shared(std::move(r)); + + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + struct State + { + explicit State(std::shared_ptr rangeArg) : cancel(false) { + this->range = std::move(rangeArg); + this->r_cursor = begin(*this->range); + this->r_end = end(*this->range); + } + bool cancel; + std::shared_ptr range; + It r_cursor; + It r_end; + }; + auto state = std::make_shared(range); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + state->cancel = true; + })); + + cd.Add(scheduler->Schedule( + fix0([=](Scheduler::shared s, std::function self) -> Disposable + { + if (state->cancel) + return Disposable::Empty(); + + if (state->r_cursor == state->r_end) + { + observer->OnCompleted(); + } + else + { + observer->OnNext(*state->r_cursor); + ++state->r_cursor; + return s->Schedule(std::move(self)); + } + return Disposable::Empty(); + }))); + + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 3330fc4..adb541f 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -893,71 +893,11 @@ namespace rxcpp #include "operators/Range.hpp" #include "operators/Random.hpp" #include "operators/Interval.hpp" +#include "operators/Iterate.hpp" namespace rxcpp { - using std::begin; - using std::end; - template - auto Iterate( - Range r, - Scheduler::shared scheduler = nullptr) - -> std::shared_ptr::type>> - { - typedef decltype(begin(r)) It; - typedef typename std::decay::type T; - - if (!scheduler) {scheduler = std::make_shared();} - auto range = std::make_shared(std::move(r)); - - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - explicit State(std::shared_ptr rangeArg) : cancel(false) { - this->range = std::move(rangeArg); - this->r_cursor = begin(*this->range); - this->r_end = end(*this->range); - } - bool cancel; - std::shared_ptr range; - It r_cursor; - It r_end; - }; - auto state = std::make_shared(range); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - state->cancel = true; - })); - - cd.Add(scheduler->Schedule( - fix0([=](Scheduler::shared s, std::function self) -> Disposable - { - if (state->cancel) - return Disposable::Empty(); - - if (state->r_cursor == state->r_end) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(*state->r_cursor); - ++state->r_cursor; - return s->Schedule(std::move(self)); - } - return Disposable::Empty(); - }))); - - return cd; - }); - } - - namespace detail { template -- GitLab From 69cf3a33140b05658fb312bf3c4ab0941d1cfbcc Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:43:53 -0800 Subject: [PATCH 091/782] move Using to separate header --- Rx/CPP/src/cpprx/operators/Using.hpp | 111 +++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 98 +---------------------- 2 files changed, 112 insertions(+), 97 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Using.hpp diff --git a/Rx/CPP/src/cpprx/operators/Using.hpp b/Rx/CPP/src/cpprx/operators/Using.hpp new file mode 100644 index 0000000..634bfc6 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Using.hpp @@ -0,0 +1,111 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_USING_HPP) +#define CPPRX_RX_OPERATORS_USING_HPP + +namespace rxcpp +{ + + namespace detail + { + template + class UsingObservable : public Producer, T> + { + typedef UsingObservable This; + typedef std::shared_ptr Parent; + typedef std::shared_ptr> Source; + + public: + typedef std::function ResourceFactory; + typedef std::function ObservableFactory; + + private: + ResourceFactory resourceFactory; + ObservableFactory observableFactory; + + class _ : public Sink<_, T>, public Observer + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + ComposableDisposable cd; + Source source; + auto disposable = Disposable::Empty(); + + try + { + auto resource = parent->resourceFactory(); + disposable = resource; + source = parent->observableFactory(resource); + } + catch (...) + { + cd.Add(Throw(std::current_exception())->Subscribe(this->shared_from_this())); + cd.Add(std::move(disposable)); + return cd; + } + + cd.Add(source->Subscribe(this->shared_from_this())); + cd.Add(std::move(disposable)); + return cd; + } + + virtual void OnNext(const T& t) + { + SinkBase::observer->OnNext(t); + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer ProducerBase; + public: + + UsingObservable(ResourceFactory resourceFactory, ObservableFactory observableFactory) : + ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + resourceFactory(resourceFactory), + observableFactory(observableFactory) + { + } + }; + } + template + auto Using( + RF resourceFactory, + OF observableFactory + ) + -> decltype(observableFactory(resourceFactory())) + { + typedef typename observable_item::type T; + typedef decltype(resourceFactory()) R; + return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index adb541f..5a44b35 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -894,107 +894,11 @@ namespace rxcpp #include "operators/Random.hpp" #include "operators/Interval.hpp" #include "operators/Iterate.hpp" +#include "operators/Using.hpp" namespace rxcpp { - namespace detail - { - template - class UsingObservable : public Producer, T> - { - typedef UsingObservable This; - typedef std::shared_ptr Parent; - typedef std::shared_ptr> Source; - - public: - typedef std::function ResourceFactory; - typedef std::function ObservableFactory; - - private: - ResourceFactory resourceFactory; - ObservableFactory observableFactory; - - class _ : public Sink<_, T>, public Observer - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - ComposableDisposable cd; - Source source; - auto disposable = Disposable::Empty(); - - try - { - auto resource = parent->resourceFactory(); - disposable = resource; - source = parent->observableFactory(resource); - } - catch (...) - { - cd.Add(Throw(std::current_exception())->Subscribe(this->shared_from_this())); - cd.Add(std::move(disposable)); - return cd; - } - - cd.Add(source->Subscribe(this->shared_from_this())); - cd.Add(std::move(disposable)); - return cd; - } - - virtual void OnNext(const T& t) - { - SinkBase::observer->OnNext(t); - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer ProducerBase; - public: - - UsingObservable(ResourceFactory resourceFactory, ObservableFactory observableFactory) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - resourceFactory(resourceFactory), - observableFactory(observableFactory) - { - } - }; - } - template - auto Using( - RF resourceFactory, - OF observableFactory - ) - -> decltype(observableFactory(resourceFactory())) - { - typedef typename observable_item::type T; - typedef decltype(resourceFactory()) R; - return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); - } ////////////////////////////////////////////////////////////////////// // -- GitLab From 11143407fc6640379540fbc3b93a80a3ea8f19b0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:47:12 -0800 Subject: [PATCH 092/782] move Select to separate header --- Rx/CPP/src/cpprx/operators/Select.hpp | 52 +++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 66 ++++++--------------------- 2 files changed, 66 insertions(+), 52 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Select.hpp diff --git a/Rx/CPP/src/cpprx/operators/Select.hpp b/Rx/CPP/src/cpprx/operators/Select.hpp new file mode 100644 index 0000000..42d40be --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Select.hpp @@ -0,0 +1,52 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_SELECT_HPP) +#define CPPRX_RX_OPERATORS_SELECT_HPP + +namespace rxcpp +{ + + template + auto Select( + const std::shared_ptr>& source, + S selector + ) + -> const std::shared_ptr::type>> + { + typedef typename std::result_of::type U; + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + util::maybe result; + try { + result.set(selector(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + observer->OnNext(std::move(*result.get())); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 5a44b35..b9a1c83 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -885,20 +885,6 @@ namespace rxcpp { return fix0_thunk(std::move(f)); } -} - -#include "operators/Empty.hpp" -#include "operators/Return.hpp" -#include "operators/Throw.hpp" -#include "operators/Range.hpp" -#include "operators/Random.hpp" -#include "operators/Interval.hpp" -#include "operators/Iterate.hpp" -#include "operators/Using.hpp" - -namespace rxcpp -{ - ////////////////////////////////////////////////////////////////////// // @@ -953,49 +939,25 @@ namespace rxcpp if (error != std::exception_ptr()) { std::rethrow_exception(error);} } +} + +#include "operators/Empty.hpp" +#include "operators/Return.hpp" +#include "operators/Throw.hpp" +#include "operators/Range.hpp" +#include "operators/Random.hpp" +#include "operators/Interval.hpp" +#include "operators/Iterate.hpp" +#include "operators/Using.hpp" +#include "operators/Select.hpp" + +namespace rxcpp +{ ////////////////////////////////////////////////////////////////////// // // standard query operators - template - auto Select( - const std::shared_ptr>& source, - S selector - ) - -> const std::shared_ptr::type>> - { - typedef typename std::result_of::type U; - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - util::maybe result; - try { - result.set(selector(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } template auto SelectMany( -- GitLab From 4b637be9a55d4aa1e0390defc4d9512ecd83b240 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:49:43 -0800 Subject: [PATCH 093/782] move SelectMany to separate header --- Rx/CPP/src/cpprx/operators/SelectMany.hpp | 156 ++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 153 +-------------------- 2 files changed, 161 insertions(+), 148 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/SelectMany.hpp diff --git a/Rx/CPP/src/cpprx/operators/SelectMany.hpp b/Rx/CPP/src/cpprx/operators/SelectMany.hpp new file mode 100644 index 0000000..b24cb20 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/SelectMany.hpp @@ -0,0 +1,156 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_SELECTMANY_HPP) +#define CPPRX_RX_OPERATORS_SELECTMANY_HPP + +namespace rxcpp +{ + + template + auto SelectMany( + const std::shared_ptr>& source, + CS collectionSelector, + RS resultSelector) + -> const std::shared_ptr::type>::type&)>::type>> + { + typedef typename std::decay::type>::type C; + typedef typename observable_item::type CI; + typedef typename std::result_of::type U; + + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + size_t subscribed; + bool cancel; + std::mutex lock; + }; + auto state = std::make_shared(); + state->cancel = false; + state->subscribed = 0; + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + std::unique_lock guard(state->lock); + state->cancel = true; }) + ); + + ++state->subscribed; + cd.Add(Subscribe( + source, + // on next + [=](const T& sourceElement) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + if (!cancel) ++state->subscribed; + } + if (!cancel) { + util::maybe collection; + try { + collection.set(collectionSelector(sourceElement)); + } catch(...) { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + } + if (!!collection) { + cd.Add(Subscribe( + *collection.get(), + // on next + [=](const CI& collectionElement) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + util::maybe result; + try { + result.set(resultSelector(sourceElement, collectionElement)); + } catch(...) { + observer->OnError(std::current_exception()); + cd.Dispose(); + } + if (!!result) { + observer->OnNext(std::move(*result.get())); + } + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + finished = (--state->subscribed) == 0; + cancel = state->cancel; + } + if (!cancel && finished) + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + --state->subscribed; + cancel = state->cancel; + } + if (!cancel) + observer->OnError(error); + cd.Dispose(); + })); + } + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + finished = (--state->subscribed) == 0; + cancel = state->cancel; + } + if (!cancel && finished) + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + --state->subscribed; + cancel = state->cancel; + } + if (!cancel) + observer->OnError(error); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index b9a1c83..fb3bbf1 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -949,158 +949,15 @@ namespace rxcpp #include "operators/Interval.hpp" #include "operators/Iterate.hpp" #include "operators/Using.hpp" + +////////////////////////////////////////////////////////////////////// +// +// standard query operators #include "operators/Select.hpp" +#include "operators/SelectMany.hpp" namespace rxcpp { - - ////////////////////////////////////////////////////////////////////// - // - // standard query operators - - - template - auto SelectMany( - const std::shared_ptr>& source, - CS collectionSelector, - RS resultSelector) - -> const std::shared_ptr::type>::type&)>::type>> - { - typedef typename std::decay::type>::type C; - typedef typename observable_item::type CI; - typedef typename std::result_of::type U; - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - size_t subscribed; - bool cancel; - std::mutex lock; - }; - auto state = std::make_shared(); - state->cancel = false; - state->subscribed = 0; - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - std::unique_lock guard(state->lock); - state->cancel = true; }) - ); - - ++state->subscribed; - cd.Add(Subscribe( - source, - // on next - [=](const T& sourceElement) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - if (!cancel) ++state->subscribed; - } - if (!cancel) { - util::maybe collection; - try { - collection.set(collectionSelector(sourceElement)); - } catch(...) { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); - } - if (!!collection) { - cd.Add(Subscribe( - *collection.get(), - // on next - [=](const CI& collectionElement) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - util::maybe result; - try { - result.set(resultSelector(sourceElement, collectionElement)); - } catch(...) { - observer->OnError(std::current_exception()); - cd.Dispose(); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - { - std::unique_lock guard(state->lock); - finished = (--state->subscribed) == 0; - cancel = state->cancel; - } - if (!cancel && finished) - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - --state->subscribed; - cancel = state->cancel; - } - if (!cancel) - observer->OnError(error); - cd.Dispose(); - })); - } - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - { - std::unique_lock guard(state->lock); - finished = (--state->subscribed) == 0; - cancel = state->cancel; - } - if (!cancel && finished) - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - --state->subscribed; - cancel = state->cancel; - } - if (!cancel) - observer->OnError(error); - })); - return cd; - }); - } template ObservableT Concat( -- GitLab From 75e10aa5b853575385e23560e6ec2bed4cf9bf1c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:51:36 -0800 Subject: [PATCH 094/782] move Concat to separate header --- Rx/CPP/src/cpprx/operators/Concat.hpp | 161 ++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 148 +---------------------- 2 files changed, 162 insertions(+), 147 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Concat.hpp diff --git a/Rx/CPP/src/cpprx/operators/Concat.hpp b/Rx/CPP/src/cpprx/operators/Concat.hpp new file mode 100644 index 0000000..e173732 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Concat.hpp @@ -0,0 +1,161 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_CONCAT_HPP) +#define CPPRX_RX_OPERATORS_CONCAT_HPP + +namespace rxcpp +{ + + template + ObservableT Concat( + const std::shared_ptr>& source) + { + typedef typename observable_item::type T; + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + bool completed; + bool subscribed; + bool cancel; + std::queue queue; + Scheduler::shared scheduler; + std::mutex lock; + }; + auto state = std::make_shared(); + state->cancel = false; + state->subscribed = 0; + state->scheduler = std::make_shared(); + + ComposableDisposable cd; + + SerialDisposable sd; + cd.Add(sd); + + cd.Add(Disposable([=]{ + std::unique_lock guard(state->lock); + state->cancel = true; }) + ); + + cd.Add(Subscribe( + source, + // on next + [=](const ObservableT& sourceElement) + { + bool cancel = false; + bool subscribed = false; + Scheduler::shared sched; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + sched = state->scheduler; + if (!cancel) { + subscribed = state->subscribed; + state->queue.push(sourceElement); + state->subscribed = true; + sched = state->scheduler; + } + } + if (!cancel && !subscribed) { + sd.Set(sched->Schedule( + fix0([state, cd, sd, observer](Scheduler::shared s, std::function self) -> Disposable + { + bool cancel = false; + bool finished = false; + ObservableT next; + { + std::unique_lock guard(state->lock); + finished = state->queue.empty(); + cancel = state->cancel; + if (!cancel && !finished) {next = state->queue.front(); state->queue.pop();} + } + if (!cancel && !finished) { + sd.Set(Subscribe( + next, + // on next + [=](const T& t) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnNext(std::move(t)); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + bool subscribe = false; + { + std::unique_lock guard(state->lock); + finished = state->queue.empty() && state->completed; + subscribe = !state->queue.empty(); + state->subscribed = subscribe; + cancel = state->cancel; + } + if (!cancel) { + if (subscribe) {sd.Set(s->Schedule(std::move(self)));} + else if (finished) {observer->OnCompleted(); cd.Dispose();} + } + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + })); + } + return Disposable::Empty(); + }))); + } + }, + // on completed + [=] + { + bool cancel = false; + bool finished = false; + { + std::unique_lock guard(state->lock); + state->completed = true; + finished = state->queue.empty() && !state->subscribed; + cancel = state->cancel; + } + if (!cancel && finished) { + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + bool cancel = false; + { + std::unique_lock guard(state->lock); + cancel = state->cancel; + } + if (!cancel) { + observer->OnError(std::current_exception()); + } + cd.Dispose(); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index fb3bbf1..49ce6ad 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -955,157 +955,11 @@ namespace rxcpp // standard query operators #include "operators/Select.hpp" #include "operators/SelectMany.hpp" +#include "operators/Concat.hpp" namespace rxcpp { - template - ObservableT Concat( - const std::shared_ptr>& source) - { - typedef typename observable_item::type T; - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - bool completed; - bool subscribed; - bool cancel; - std::queue queue; - Scheduler::shared scheduler; - std::mutex lock; - }; - auto state = std::make_shared(); - state->cancel = false; - state->subscribed = 0; - state->scheduler = std::make_shared(); - - ComposableDisposable cd; - - SerialDisposable sd; - cd.Add(sd); - - cd.Add(Disposable([=]{ - std::unique_lock guard(state->lock); - state->cancel = true; }) - ); - - cd.Add(Subscribe( - source, - // on next - [=](const ObservableT& sourceElement) - { - bool cancel = false; - bool subscribed = false; - Scheduler::shared sched; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - sched = state->scheduler; - if (!cancel) { - subscribed = state->subscribed; - state->queue.push(sourceElement); - state->subscribed = true; - sched = state->scheduler; - } - } - if (!cancel && !subscribed) { - sd.Set(sched->Schedule( - fix0([state, cd, sd, observer](Scheduler::shared s, std::function self) -> Disposable - { - bool cancel = false; - bool finished = false; - ObservableT next; - { - std::unique_lock guard(state->lock); - finished = state->queue.empty(); - cancel = state->cancel; - if (!cancel && !finished) {next = state->queue.front(); state->queue.pop();} - } - if (!cancel && !finished) { - sd.Set(Subscribe( - next, - // on next - [=](const T& t) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnNext(std::move(t)); - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - bool subscribe = false; - { - std::unique_lock guard(state->lock); - finished = state->queue.empty() && state->completed; - subscribe = !state->queue.empty(); - state->subscribed = subscribe; - cancel = state->cancel; - } - if (!cancel) { - if (subscribe) {sd.Set(s->Schedule(std::move(self)));} - else if (finished) {observer->OnCompleted(); cd.Dispose();} - } - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); - })); - } - return Disposable::Empty(); - }))); - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - { - std::unique_lock guard(state->lock); - state->completed = true; - finished = state->queue.empty() && !state->subscribed; - cancel = state->cancel; - } - if (!cancel && finished) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); - })); - return cd; - }); - } namespace detail{ template -- GitLab From bc3c7ccdc08917609762d6719931aa449e4dbad4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:57:13 -0800 Subject: [PATCH 095/782] move CombineLatest to separate header --- Rx/CPP/src/cpprx/operators/CombineLatest.hpp | 187 +++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 175 +---------------- 2 files changed, 188 insertions(+), 174 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/CombineLatest.hpp diff --git a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp new file mode 100644 index 0000000..0e98c3f --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp @@ -0,0 +1,187 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_COMBINELATEST_HPP) +#define CPPRX_RX_OPERATORS_COMBINELATEST_HPP + +namespace rxcpp +{ + + namespace detail{ + template + struct CombineLatestSubscriber { + typedef typename SubscribeState::Latest Latest; + static void subscribe( + ComposableDisposable& cd, + const std::shared_ptr>& observer, + const std::shared_ptr& state, + const typename SubscribeState::Sources& sources) { + cd.Add(Subscribe( + std::get(sources), + // on next + [=](const typename std::tuple_element::type& element) + { + auto local = state; + std::unique_lock guard(local->lock); + std::get(local->latest) = element; + if (!std::get(local->latestValid)) { + std::get(local->latestValid) = true; + --local->pendingFirst; + } + if (local->pendingFirst == 0) { + Latest args = local->latest; + typedef decltype(util::tuple_dispatch(local->selector, args)) U; + util::maybe result; + try { + result.set(util::tuple_dispatch(local->selector, args)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + ++state->pendingIssue; + { + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + observer->OnNext(std::move(*result.get())); + } + --state->pendingIssue; + } + if (state->done && state->pendingIssue == 0) { + guard.unlock(); + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on completed + [=] + { + std::unique_lock guard(state->lock); + --state->pendingComplete; + if (state->pendingComplete == 0) { + state->done = true; + if (state->pendingIssue == 0) { + guard.unlock(); + observer->OnCompleted(); + cd.Dispose(); + } + } + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + CombineLatestSubscriber:: + subscribe(cd, observer, state, sources); + } + }; + template + struct CombineLatestSubscriber { + static void subscribe( + ComposableDisposable& , + const std::shared_ptr>& , + const std::shared_ptr& , + const typename SubscribeState::Sources& ) {} + }; + } + +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto CombineLatest( + S selector, + const std::shared_ptr>&... source + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>...> Sources; + typedef std::tuple Latest; + typedef decltype(std::make_tuple((source, true)...)) LatestValid; + struct State { + typedef Latest Latest; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : latestValid() + , pendingFirst(SourcesSize::value) + , pendingIssue(0) + , pendingComplete(SourcesSize::value) + , done(false) + , selector(std::move(selector)) + {} + std::mutex lock; + LatestValid latestValid; + size_t pendingFirst; + size_t pendingIssue; + size_t pendingComplete; + bool done; + S selector; + Latest latest; + }; + Sources sources(source...); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(selector)); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#else + template + auto CombineLatest( + S selector, + const std::shared_ptr>& source1, + const std::shared_ptr>& source2 + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>, std::shared_ptr>> Sources; + typedef std::tuple Latest; + typedef std::tuple LatestValid; + struct State { + typedef Latest Latest; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : latestValid() + , pendingFirst(SourcesSize::value) + , pendingIssue(0) + , pendingComplete(SourcesSize::value) + , done(false) + , selector(std::move(selector)) + {} + std::mutex lock; + LatestValid latestValid; + size_t pendingFirst; + size_t pendingIssue; + size_t pendingComplete; + bool done; + S selector; + Latest latest; + }; + Sources sources(source1, source2); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#endif + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 49ce6ad..2a58f01 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -956,183 +956,10 @@ namespace rxcpp #include "operators/Select.hpp" #include "operators/SelectMany.hpp" #include "operators/Concat.hpp" +#include "operators/CombineLatest.hpp" namespace rxcpp { - - - namespace detail{ - template - struct CombineLatestSubscriber { - typedef typename SubscribeState::Latest Latest; - static void subscribe( - ComposableDisposable& cd, - const std::shared_ptr>& observer, - const std::shared_ptr& state, - const typename SubscribeState::Sources& sources) { - cd.Add(Subscribe( - std::get(sources), - // on next - [=](const typename std::tuple_element::type& element) - { - auto local = state; - std::unique_lock guard(local->lock); - std::get(local->latest) = element; - if (!std::get(local->latestValid)) { - std::get(local->latestValid) = true; - --local->pendingFirst; - } - if (local->pendingFirst == 0) { - Latest args = local->latest; - typedef decltype(util::tuple_dispatch(local->selector, args)) U; - util::maybe result; - try { - result.set(util::tuple_dispatch(local->selector, args)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - ++state->pendingIssue; - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(*result.get())); - } - --state->pendingIssue; - } - if (state->done && state->pendingIssue == 0) { - guard.unlock(); - observer->OnCompleted(); - cd.Dispose(); - } - } - }, - // on completed - [=] - { - std::unique_lock guard(state->lock); - --state->pendingComplete; - if (state->pendingComplete == 0) { - state->done = true; - if (state->pendingIssue == 0) { - guard.unlock(); - observer->OnCompleted(); - cd.Dispose(); - } - } - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - CombineLatestSubscriber:: - subscribe(cd, observer, state, sources); - } - }; - template - struct CombineLatestSubscriber { - static void subscribe( - ComposableDisposable& , - const std::shared_ptr>& , - const std::shared_ptr& , - const typename SubscribeState::Sources& ) {} - }; - } - -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto CombineLatest( - S selector, - const std::shared_ptr>&... source - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>...> Sources; - typedef std::tuple Latest; - typedef decltype(std::make_tuple((source, true)...)) LatestValid; - struct State { - typedef Latest Latest; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : latestValid() - , pendingFirst(SourcesSize::value) - , pendingIssue(0) - , pendingComplete(SourcesSize::value) - , done(false) - , selector(std::move(selector)) - {} - std::mutex lock; - LatestValid latestValid; - size_t pendingFirst; - size_t pendingIssue; - size_t pendingComplete; - bool done; - S selector; - Latest latest; - }; - Sources sources(source...); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(selector)); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#else - template - auto CombineLatest( - S selector, - const std::shared_ptr>& source1, - const std::shared_ptr>& source2 - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>, std::shared_ptr>> Sources; - typedef std::tuple Latest; - typedef std::tuple LatestValid; - struct State { - typedef Latest Latest; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : latestValid() - , pendingFirst(SourcesSize::value) - , pendingIssue(0) - , pendingComplete(SourcesSize::value) - , done(false) - , selector(std::move(selector)) - {} - std::mutex lock; - LatestValid latestValid; - size_t pendingFirst; - size_t pendingIssue; - size_t pendingComplete; - bool done; - S selector; - Latest latest; - }; - Sources sources(source1, source2); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#endif namespace detail{ template -- GitLab From 8c0e56c78673dc390239f82402b9e22e58197d74 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:57:44 -0800 Subject: [PATCH 096/782] move Zip to separate header --- Rx/CPP/src/cpprx/operators/Zip.hpp | 215 +++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 203 +-------------------------- 2 files changed, 216 insertions(+), 202 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Zip.hpp diff --git a/Rx/CPP/src/cpprx/operators/Zip.hpp b/Rx/CPP/src/cpprx/operators/Zip.hpp new file mode 100644 index 0000000..3d51f0c --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Zip.hpp @@ -0,0 +1,215 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_ZIP_HPP) +#define CPPRX_RX_OPERATORS_ZIP_HPP + +namespace rxcpp +{ + + namespace detail{ + template + struct ZipSubscriber { + typedef typename std::tuple_element::type::second_type::value_type Item; + typedef std::shared_ptr> ResultObserver; + struct Next + { + std::shared_ptr state; + const ResultObserver& observer; + const ComposableDisposable& cd; + explicit Next( + std::shared_ptr state, + const ResultObserver& observer, + const ComposableDisposable& cd) + : state(std::move(state)) + , observer(observer) + , cd(cd) { + } +#if RXCPP_USE_VARIADIC_TEMPLATES + template + void operator()(ZipQueue&... queue) { + // build array of bool that we can iterate to detect empty queues + bool empties[] = {queue.second.empty()...}; + if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { + // all queues have an item. + // + // copy front of each queue + auto args = std::make_tuple(queue.second.front()...); + + // cause side-effect of pop on each queue + std::make_tuple((queue.second.pop(), true)...); + + typedef decltype(util::tuple_dispatch(state->selector, args)) U; + util::maybe result; + try { + result.set(util::tuple_dispatch(state->selector, args)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + observer->OnNext(std::move(*result.get())); + } + } + // build new array to check for any empty queue + bool post_empties[] = {queue.first && queue.second.empty()...}; + if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { + // at least one queue is empty and at least one of the sources has completed. + // it is time to stop. + observer->OnCompleted(); + cd.Dispose(); + } + } +#else + template + void operator()(ZipQueue1& queue1, ZipQueue2& queue2) { + // build array of bool that we can iterate to detect empty queues + bool empties[] = {queue1.second.empty(), queue2.second.empty()}; + if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { + // all queues have an item. + // + // copy front of each queue + auto args = std::make_tuple(queue1.second.front(), queue2.second.front()); + + queue1.second.pop(); + queue2.second.pop(); + + typedef decltype(util::tuple_dispatch(state->selector, args)) U; + util::maybe result; + try { + result.set(util::tuple_dispatch(state->selector, args)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + observer->OnNext(std::move(*result.get())); + } + } + // build new array to check for any empty queue + bool post_empties[] = {queue1.first && queue1.second.empty(), queue2.first && queue2.second.empty()}; + if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { + // at least one queue is empty and at least one of the sources has completed. + // it is time to stop. + observer->OnCompleted(); + cd.Dispose(); + } + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES + }; + static void subscribe( + ComposableDisposable& cd, + const std::shared_ptr>& observer, + const std::shared_ptr& state, + const typename SubscribeState::Sources& sources) { + cd.Add(Subscribe( + std::get(sources), + // on next + [=](const Item& element) + { + std::unique_lock guard(state->lock); + std::get(state->queues).second.push(element); + Next next(state, observer, cd); + util::tuple_dispatch(next, state->queues); + }, + // on completed + [=] + { + std::unique_lock guard(state->lock); + std::get(state->queues).first = true; + Next next(state, observer, cd); + util::tuple_dispatch(next, state->queues); + }, + // on error + [=](const std::exception_ptr& error) + { + std::unique_lock guard(state->lock); + observer->OnError(error); + cd.Dispose(); + })); + ZipSubscriber:: + subscribe(cd, observer, state, sources); + } + }; + template + struct ZipSubscriber { + static void subscribe( + ComposableDisposable& , + const std::shared_ptr>& , + const std::shared_ptr& , + const typename SubscribeState::Sources& ) {} + }; + } +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto Zip( + S selector, + const std::shared_ptr>&... source + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>...> Sources; + typedef std::tuple>...> Queues; + struct State { + typedef Queues Queues; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : selector(std::move(selector)) + {} + std::mutex lock; + S selector; + Queues queues; + }; + Sources sources(source...); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#else + template + auto Zip( + S selector, + const std::shared_ptr>& source1, + const std::shared_ptr>& source2 + ) + -> std::shared_ptr::type>> + { + typedef typename std::result_of::type result_type; + typedef std::tuple>, std::shared_ptr>> Sources; + typedef std::tuple>, std::pair>> Queues; + struct State { + typedef Queues Queues; + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + explicit State(S selector) + : selector(std::move(selector)) + {} + std::mutex lock; + S selector; + Queues queues; + }; + Sources sources(source1, source2); + // bug on osx prevents using make_shared + std::shared_ptr state(new State(std::move(selector))); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 2a58f01..b6a35d5 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -957,212 +957,11 @@ namespace rxcpp #include "operators/SelectMany.hpp" #include "operators/Concat.hpp" #include "operators/CombineLatest.hpp" +#include "operators/Zip.hpp" namespace rxcpp { - namespace detail{ - template - struct ZipSubscriber { - typedef typename std::tuple_element::type::second_type::value_type Item; - typedef std::shared_ptr> ResultObserver; - struct Next - { - std::shared_ptr state; - const ResultObserver& observer; - const ComposableDisposable& cd; - explicit Next( - std::shared_ptr state, - const ResultObserver& observer, - const ComposableDisposable& cd) - : state(std::move(state)) - , observer(observer) - , cd(cd) { - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - void operator()(ZipQueue&... queue) { - // build array of bool that we can iterate to detect empty queues - bool empties[] = {queue.second.empty()...}; - if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { - // all queues have an item. - // - // copy front of each queue - auto args = std::make_tuple(queue.second.front()...); - - // cause side-effect of pop on each queue - std::make_tuple((queue.second.pop(), true)...); - - typedef decltype(util::tuple_dispatch(state->selector, args)) U; - util::maybe result; - try { - result.set(util::tuple_dispatch(state->selector, args)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - // build new array to check for any empty queue - bool post_empties[] = {queue.first && queue.second.empty()...}; - if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { - // at least one queue is empty and at least one of the sources has completed. - // it is time to stop. - observer->OnCompleted(); - cd.Dispose(); - } - } -#else - template - void operator()(ZipQueue1& queue1, ZipQueue2& queue2) { - // build array of bool that we can iterate to detect empty queues - bool empties[] = {queue1.second.empty(), queue2.second.empty()}; - if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { - // all queues have an item. - // - // copy front of each queue - auto args = std::make_tuple(queue1.second.front(), queue2.second.front()); - - queue1.second.pop(); - queue2.second.pop(); - - typedef decltype(util::tuple_dispatch(state->selector, args)) U; - util::maybe result; - try { - result.set(util::tuple_dispatch(state->selector, args)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - // build new array to check for any empty queue - bool post_empties[] = {queue1.first && queue1.second.empty(), queue2.first && queue2.second.empty()}; - if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { - // at least one queue is empty and at least one of the sources has completed. - // it is time to stop. - observer->OnCompleted(); - cd.Dispose(); - } - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES - }; - static void subscribe( - ComposableDisposable& cd, - const std::shared_ptr>& observer, - const std::shared_ptr& state, - const typename SubscribeState::Sources& sources) { - cd.Add(Subscribe( - std::get(sources), - // on next - [=](const Item& element) - { - std::unique_lock guard(state->lock); - std::get(state->queues).second.push(element); - Next next(state, observer, cd); - util::tuple_dispatch(next, state->queues); - }, - // on completed - [=] - { - std::unique_lock guard(state->lock); - std::get(state->queues).first = true; - Next next(state, observer, cd); - util::tuple_dispatch(next, state->queues); - }, - // on error - [=](const std::exception_ptr& error) - { - std::unique_lock guard(state->lock); - observer->OnError(error); - cd.Dispose(); - })); - ZipSubscriber:: - subscribe(cd, observer, state, sources); - } - }; - template - struct ZipSubscriber { - static void subscribe( - ComposableDisposable& , - const std::shared_ptr>& , - const std::shared_ptr& , - const typename SubscribeState::Sources& ) {} - }; - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto Zip( - S selector, - const std::shared_ptr>&... source - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>...> Sources; - typedef std::tuple>...> Queues; - struct State { - typedef Queues Queues; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : selector(std::move(selector)) - {} - std::mutex lock; - S selector; - Queues queues; - }; - Sources sources(source...); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#else - template - auto Zip( - S selector, - const std::shared_ptr>& source1, - const std::shared_ptr>& source2 - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>, std::shared_ptr>> Sources; - typedef std::tuple>, std::pair>> Queues; - struct State { - typedef Queues Queues; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : selector(std::move(selector)) - {} - std::mutex lock; - S selector; - Queues queues; - }; - Sources sources(source1, source2); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES - namespace detail{ template struct MergeSubscriber { -- GitLab From 798d552e353da14472a3e1443d370f26b6818cf8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 12:59:47 -0800 Subject: [PATCH 097/782] move Merge to separate header --- Rx/CPP/src/cpprx/operators/Merge.hpp | 117 +++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 105 +----------------------- 2 files changed, 118 insertions(+), 104 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Merge.hpp diff --git a/Rx/CPP/src/cpprx/operators/Merge.hpp b/Rx/CPP/src/cpprx/operators/Merge.hpp new file mode 100644 index 0000000..793acdf --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Merge.hpp @@ -0,0 +1,117 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_MERGE_HPP) +#define CPPRX_RX_OPERATORS_MERGE_HPP + +namespace rxcpp +{ + + namespace detail{ + template + struct MergeSubscriber { + typedef typename SubscribeState::result_type Item; + typedef std::shared_ptr> ResultObserver; + static void subscribe( + ComposableDisposable& cd, + const std::shared_ptr>& observer, + const std::shared_ptr& state, + const typename SubscribeState::Sources& sources) { + cd.Add(Subscribe( + std::get(sources), + // on next + [=](const Item& element) + { + observer->OnNext(element); + }, + // on completed + [=] + { + if (--state->pendingComplete == 0) { + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + MergeSubscriber:: + subscribe(cd, observer, state, sources); + } + }; + template + struct MergeSubscriber { + static void subscribe( + ComposableDisposable& , + const std::shared_ptr>& , + const std::shared_ptr& , + const typename SubscribeState::Sources& ) {} + }; + } +#if RXCPP_USE_VARIADIC_TEMPLATES + template + std::shared_ptr> Merge( + const std::shared_ptr>& firstSource, + const std::shared_ptr>&... otherSource + ) + { + typedef MergeSource result_type; + typedef decltype(std::make_tuple(firstSource, otherSource...)) Sources; + struct State { + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + State() + : pendingComplete(SourcesSize::value) + {} + std::atomic pendingComplete; + }; + Sources sources(firstSource, otherSource...); + // bug on osx prevents using make_shared + std::shared_ptr state(new State()); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#else + template + std::shared_ptr> Merge( + const std::shared_ptr>& firstSource, + const std::shared_ptr>& otherSource + ) + { + typedef MergeSource result_type; + typedef decltype(std::make_tuple(firstSource, otherSource)) Sources; + struct State { + typedef Sources Sources; + typedef result_type result_type; + typedef std::tuple_size SourcesSize; + State() + : pendingComplete(SourcesSize::value) + {} + std::atomic pendingComplete; + }; + Sources sources(firstSource, otherSource); + // bug on osx prevents using make_shared + std::shared_ptr state(new State()); + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + ComposableDisposable cd; + detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); + return cd; + }); + } +#endif //RXCPP_USE_VARIADIC_TEMPLATES +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index b6a35d5..c55efaa 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -958,114 +958,11 @@ namespace rxcpp #include "operators/Concat.hpp" #include "operators/CombineLatest.hpp" #include "operators/Zip.hpp" +#include "operators/Merge.hpp" namespace rxcpp { - namespace detail{ - template - struct MergeSubscriber { - typedef typename SubscribeState::result_type Item; - typedef std::shared_ptr> ResultObserver; - static void subscribe( - ComposableDisposable& cd, - const std::shared_ptr>& observer, - const std::shared_ptr& state, - const typename SubscribeState::Sources& sources) { - cd.Add(Subscribe( - std::get(sources), - // on next - [=](const Item& element) - { - observer->OnNext(element); - }, - // on completed - [=] - { - if (--state->pendingComplete == 0) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - MergeSubscriber:: - subscribe(cd, observer, state, sources); - } - }; - template - struct MergeSubscriber { - static void subscribe( - ComposableDisposable& , - const std::shared_ptr>& , - const std::shared_ptr& , - const typename SubscribeState::Sources& ) {} - }; - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - std::shared_ptr> Merge( - const std::shared_ptr>& firstSource, - const std::shared_ptr>&... otherSource - ) - { - typedef MergeSource result_type; - typedef decltype(std::make_tuple(firstSource, otherSource...)) Sources; - struct State { - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - State() - : pendingComplete(SourcesSize::value) - {} - std::atomic pendingComplete; - }; - Sources sources(firstSource, otherSource...); - // bug on osx prevents using make_shared - std::shared_ptr state(new State()); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#else - template - std::shared_ptr> Merge( - const std::shared_ptr>& firstSource, - const std::shared_ptr>& otherSource - ) - { - typedef MergeSource result_type; - typedef decltype(std::make_tuple(firstSource, otherSource)) Sources; - struct State { - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - State() - : pendingComplete(SourcesSize::value) - {} - std::atomic pendingComplete; - }; - Sources sources(firstSource, otherSource); - // bug on osx prevents using make_shared - std::shared_ptr state(new State()); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES - template const std::shared_ptr> Where( const std::shared_ptr>& source, -- GitLab From fe8c3370c811c8103313235b828c3bcf38daa38b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:01:30 -0800 Subject: [PATCH 098/782] move Where to separate header --- Rx/CPP/src/cpprx/operators/Where.hpp | 52 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 40 +-------------------- 2 files changed, 53 insertions(+), 39 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Where.hpp diff --git a/Rx/CPP/src/cpprx/operators/Where.hpp b/Rx/CPP/src/cpprx/operators/Where.hpp new file mode 100644 index 0000000..679ffab --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Where.hpp @@ -0,0 +1,52 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_WHERE_HPP) +#define CPPRX_RX_OPERATORS_WHERE_HPP + +namespace rxcpp +{ + + template + const std::shared_ptr> Where( + const std::shared_ptr>& source, + P predicate + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + { + return Subscribe( + source, + // on next + [=](const T& element) + { + typedef decltype(predicate(element)) U; + util::maybe result; + try { + result.set(predicate(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result && *result.get()) + { + observer->OnNext(element); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index c55efaa..5be0cf1 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -959,49 +959,11 @@ namespace rxcpp #include "operators/CombineLatest.hpp" #include "operators/Zip.hpp" #include "operators/Merge.hpp" +#include "operators/Where.hpp" namespace rxcpp { - template - const std::shared_ptr> Where( - const std::shared_ptr>& source, - P predicate - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - typedef decltype(predicate(element)) U; - util::maybe result; - try { - result.set(predicate(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result && *result.get()) - { - observer->OnNext(element); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - template auto GroupBy( const std::shared_ptr>& source, -- GitLab From 88f447bb9d8cc8987e52e8b0c0291aa935d462b9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:05:25 -0800 Subject: [PATCH 099/782] move GroupBy to separate header --- Rx/CPP/src/cpprx/operators/GroupBy.hpp | 102 +++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 91 +--------------------- 2 files changed, 103 insertions(+), 90 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/GroupBy.hpp diff --git a/Rx/CPP/src/cpprx/operators/GroupBy.hpp b/Rx/CPP/src/cpprx/operators/GroupBy.hpp new file mode 100644 index 0000000..e9e7923 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/GroupBy.hpp @@ -0,0 +1,102 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_GROUPBY_HPP) +#define CPPRX_RX_OPERATORS_GRUOPBY_HPP + +namespace rxcpp +{ + + template + auto GroupBy( + const std::shared_ptr>& source, + KS keySelector, + VS valueSelector, + L less) + -> std::shared_ptr::type, + typename std::decay::type>>>> + { + typedef typename std::decay::type Key; + typedef typename std::decay::type Value; + + typedef std::shared_ptr> LocalGroupObservable; + + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + typedef std::map>, L> Groups; + + struct State + { + explicit State(L less) : groups(std::move(less)) {} + std::mutex lock; + Groups groups; + }; + auto state = std::make_shared(std::move(less)); + + return Subscribe( + source, + // on next + [=](const T& element) + { + util::maybe key; + try { + key.set(keySelector(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + + if (!!key) { + auto keySubject = CreateGroupedSubject(*key.get()); + + typename Groups::iterator groupIt; + bool newGroup = false; + + { + std::unique_lock guard(state->lock); + std::tie(groupIt, newGroup) = state->groups.insert( + std::make_pair(*key.get(), keySubject) + ); + } + + if (newGroup) + { + LocalGroupObservable nextGroup(std::move(keySubject)); + observer->OnNext(nextGroup); + } + + util::maybe result; + try { + result.set(valueSelector(element)); + } catch(...) { + observer->OnError(std::current_exception()); + } + if (!!result) { + groupIt->second->OnNext(std::move(*result.get())); + } + } + }, + // on completed + [=] + { + for(auto& group : state->groups) { + group.second->OnCompleted(); + } + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + for(auto& group : state->groups) { + group.second->OnError(error); + } + observer->OnError(error); + }); + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 5be0cf1..6f3c969 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -960,100 +960,11 @@ namespace rxcpp #include "operators/Zip.hpp" #include "operators/Merge.hpp" #include "operators/Where.hpp" +#include "operators/GroupBy.hpp" namespace rxcpp { - template - auto GroupBy( - const std::shared_ptr>& source, - KS keySelector, - VS valueSelector, - L less) - -> std::shared_ptr::type, - typename std::decay::type>>>> - { - typedef typename std::decay::type Key; - typedef typename std::decay::type Value; - - typedef std::shared_ptr> LocalGroupObservable; - - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - typedef std::map>, L> Groups; - - struct State - { - explicit State(L less) : groups(std::move(less)) {} - std::mutex lock; - Groups groups; - }; - auto state = std::make_shared(std::move(less)); - - return Subscribe( - source, - // on next - [=](const T& element) - { - util::maybe key; - try { - key.set(keySelector(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - - if (!!key) { - auto keySubject = CreateGroupedSubject(*key.get()); - - typename Groups::iterator groupIt; - bool newGroup = false; - - { - std::unique_lock guard(state->lock); - std::tie(groupIt, newGroup) = state->groups.insert( - std::make_pair(*key.get(), keySubject) - ); - } - - if (newGroup) - { - LocalGroupObservable nextGroup(std::move(keySubject)); - observer->OnNext(nextGroup); - } - - util::maybe result; - try { - result.set(valueSelector(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - groupIt->second->OnNext(std::move(*result.get())); - } - } - }, - // on completed - [=] - { - for(auto& group : state->groups) { - group.second->OnCompleted(); - } - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - for(auto& group : state->groups) { - group.second->OnError(error); - } - observer->OnError(error); - }); - }); - } - - template std::shared_ptr> Multicast(const std::shared_ptr < Observable < T >> &source, const std::shared_ptr& multicastSubject) { -- GitLab From 89118c8ff492f21cd4ef4a623afd12349015d2a9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:10:33 -0800 Subject: [PATCH 100/782] move Multicast to separate header --- Rx/CPP/src/cpprx/operators/Multicast.hpp | 20 ++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 8 +------- 2 files changed, 21 insertions(+), 7 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Multicast.hpp diff --git a/Rx/CPP/src/cpprx/operators/Multicast.hpp b/Rx/CPP/src/cpprx/operators/Multicast.hpp new file mode 100644 index 0000000..e3d9c75 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Multicast.hpp @@ -0,0 +1,20 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_MULTICAST_HPP) +#define CPPRX_RX_OPERATORS_MULTICAST_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> Multicast(const std::shared_ptr < Observable < T >> &source, const std::shared_ptr& multicastSubject) + { + return std::static_pointer_cast>( + std::make_shared < ConnectableSubject < std::shared_ptr < Observable < T >> , std::shared_ptr >> (source, multicastSubject)); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 6f3c969..22bf197 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -961,17 +961,11 @@ namespace rxcpp #include "operators/Merge.hpp" #include "operators/Where.hpp" #include "operators/GroupBy.hpp" +#include "operators/Multicast.hpp" namespace rxcpp { - template - std::shared_ptr> Multicast(const std::shared_ptr < Observable < T >> &source, const std::shared_ptr& multicastSubject) - { - return std::static_pointer_cast>( - std::make_shared < ConnectableSubject < std::shared_ptr < Observable < T >> , std::shared_ptr >> (source, multicastSubject)); - } - template std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source) { -- GitLab From 1e2b32e33e33f4c9ab6e3b9a4660cacc4d9fa9e6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:16:15 -0800 Subject: [PATCH 101/782] move Publish to separate header --- Rx/CPP/src/cpprx/operators/Publish.hpp | 34 ++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 22 ++--------------- 2 files changed, 36 insertions(+), 20 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Publish.hpp diff --git a/Rx/CPP/src/cpprx/operators/Publish.hpp b/Rx/CPP/src/cpprx/operators/Publish.hpp new file mode 100644 index 0000000..fe2fb15 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Publish.hpp @@ -0,0 +1,34 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_PUBLISH_HPP) +#define CPPRX_RX_OPERATORS_PUBLISH_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source) + { + auto multicastSubject = std::make_shared>(); + return Multicast(source, multicastSubject); + } + + template + std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source, V value) + { + auto multicastSubject = std::make_shared>(value); + return Multicast(source, multicastSubject); + } + + template + std::shared_ptr> PublishLast(const std::shared_ptr < Observable < T >> &source) + { + auto multicastSubject = std::make_shared>(); + return Multicast(source, multicastSubject); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 22bf197..037a90b 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -953,6 +953,7 @@ namespace rxcpp ////////////////////////////////////////////////////////////////////// // // standard query operators + #include "operators/Select.hpp" #include "operators/SelectMany.hpp" #include "operators/Concat.hpp" @@ -962,30 +963,11 @@ namespace rxcpp #include "operators/Where.hpp" #include "operators/GroupBy.hpp" #include "operators/Multicast.hpp" +#include "operators/Publish.hpp" namespace rxcpp { - template - std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source) - { - auto multicastSubject = std::make_shared>(); - return Multicast(source, multicastSubject); - } - - template - std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source, V value) - { - auto multicastSubject = std::make_shared>(value); - return Multicast(source, multicastSubject); - } - - template - std::shared_ptr> PublishLast(const std::shared_ptr < Observable < T >> &source) - { - auto multicastSubject = std::make_shared>(); - return Multicast(source, multicastSubject); - } namespace detail { -- GitLab From a04764b875cc8aae81236c25af589672e02bade0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:18:52 -0800 Subject: [PATCH 102/782] move RefCount to separate header --- Rx/CPP/src/cpprx/operators/RefCount.hpp | 102 ++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 91 +-------------------- 2 files changed, 103 insertions(+), 90 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/RefCount.hpp diff --git a/Rx/CPP/src/cpprx/operators/RefCount.hpp b/Rx/CPP/src/cpprx/operators/RefCount.hpp new file mode 100644 index 0000000..a1997fd --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/RefCount.hpp @@ -0,0 +1,102 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_REFCOUNT_HPP) +#define CPPRX_RX_OPERATORS_REFCOUNT_HPP + +namespace rxcpp +{ + + namespace detail + { + template + class RefCountObservable : public Producer, T> + { + std::shared_ptr> source; + std::mutex lock; + size_t refcount; + util::maybe subscription; + + class _ : public Sink<_, T>, public Observer + { + std::shared_ptr> parent; + + public: + typedef Sink<_, T> SinkBase; + + _(std::shared_ptr> parent, std::shared_ptr> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + Disposable Run() + { + SerialDisposable subscription; + subscription.Set(parent->source->Subscribe(this->shared_from_this())); + + std::unique_lock guard(parent->lock); + if (++parent->refcount == 1) + { + parent->subscription.set(parent->source->Connect()); + } + + auto local = parent; + + return Disposable([subscription, local]() + { + subscription.Dispose(); + std::unique_lock guard(local->lock); + if (--local->refcount == 0) + { + local->subscription->Dispose(); + local->subscription.reset(); + } + }); + } + + virtual void OnNext(const T& t) + { + SinkBase::observer->OnNext(t); + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer, T> ProducerBase; + public: + + RefCountObservable(std::shared_ptr> source) : + ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable&& cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(that, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return sink->Run(); + }), + refcount(0), + source(std::move(source)) + { + subscription.set(Disposable::Empty()); + } + }; + } + template + const std::shared_ptr> RefCount( + const std::shared_ptr>& source + ) + { + return std::make_shared>(source); + } +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 037a90b..219f9bd 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -964,100 +964,11 @@ namespace rxcpp #include "operators/GroupBy.hpp" #include "operators/Multicast.hpp" #include "operators/Publish.hpp" +#include "operators/RefCount.hpp" namespace rxcpp { - - namespace detail - { - template - class RefCountObservable : public Producer, T> - { - std::shared_ptr> source; - std::mutex lock; - size_t refcount; - util::maybe subscription; - - class _ : public Sink<_, T>, public Observer - { - std::shared_ptr> parent; - - public: - typedef Sink<_, T> SinkBase; - - _(std::shared_ptr> parent, std::shared_ptr> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - SerialDisposable subscription; - subscription.Set(parent->source->Subscribe(this->shared_from_this())); - - std::unique_lock guard(parent->lock); - if (++parent->refcount == 1) - { - parent->subscription.set(parent->source->Connect()); - } - - auto local = parent; - - return Disposable([subscription, local]() - { - subscription.Dispose(); - std::unique_lock guard(local->lock); - if (--local->refcount == 0) - { - local->subscription->Dispose(); - local->subscription.reset(); - } - }); - } - - virtual void OnNext(const T& t) - { - SinkBase::observer->OnNext(t); - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer, T> ProducerBase; - public: - - RefCountObservable(std::shared_ptr> source) : - ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable&& cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(that, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - refcount(0), - source(std::move(source)) - { - subscription.set(Disposable::Empty()); - } - }; - } - template - const std::shared_ptr> RefCount( - const std::shared_ptr>& source - ) - { - return std::make_shared>(source); - } - template const std::shared_ptr> ConnectForever( const std::shared_ptr>& source -- GitLab From 2ecc66c860558b5fcb8e0c2ab72218046cc65226 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:28:31 -0800 Subject: [PATCH 103/782] move ConnectForever to separate header --- Rx/CPP/src/cpprx/operators/ConnectForever.hpp | 22 +++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 10 +-------- 2 files changed, 23 insertions(+), 9 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/ConnectForever.hpp diff --git a/Rx/CPP/src/cpprx/operators/ConnectForever.hpp b/Rx/CPP/src/cpprx/operators/ConnectForever.hpp new file mode 100644 index 0000000..1c873ee --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/ConnectForever.hpp @@ -0,0 +1,22 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_CONNECTFOREVER_HPP) +#define CPPRX_RX_OPERATORS_CONNECTFOREVER_HPP + +namespace rxcpp +{ + + template + const std::shared_ptr> ConnectForever( + const std::shared_ptr>& source + ) + { + source->Connect(); + return observable(source); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 219f9bd..9779d01 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -965,19 +965,11 @@ namespace rxcpp #include "operators/Multicast.hpp" #include "operators/Publish.hpp" #include "operators/RefCount.hpp" +#include "operators/ConnectForever.hpp" namespace rxcpp { - template - const std::shared_ptr> ConnectForever( - const std::shared_ptr>& source - ) - { - source->Connect(); - return observable(source); - } - namespace detail { template -- GitLab From d7af2bda685d491f61a3ca0f9ebb02c613aa446e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 13:49:09 -0800 Subject: [PATCH 104/782] move Scan to separate header --- Rx/CPP/src/cpprx/operators/Scan.hpp | 127 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 116 +------------------------ 2 files changed, 128 insertions(+), 115 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Scan.hpp diff --git a/Rx/CPP/src/cpprx/operators/Scan.hpp b/Rx/CPP/src/cpprx/operators/Scan.hpp new file mode 100644 index 0000000..6247c8e --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Scan.hpp @@ -0,0 +1,127 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_SCAN_HPP) +#define CPPRX_RX_OPERATORS_SCAN_HPP + +namespace rxcpp +{ + namespace detail + { + template + class ScanObservable : public Producer, A> + { + typedef ScanObservable This; + typedef std::shared_ptr Parent; + typedef std::shared_ptr> Source; + typedef std::shared_ptr> Destination; + + public: + typedef std::function Accumulator; + typedef std::function(T)> Seeder; + + private: + + Source source; + util::maybe seed; + Accumulator accumulator; + Seeder seeder; + + class _ : public Sink<_, A>, public Observer + { + Parent parent; + util::maybe accumulation; + + public: + typedef Sink<_, A> SinkBase; + + _(Parent parent, Destination observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + virtual void OnNext(const T& t) + { + try + { + if (accumulation) + { + accumulation.set(parent->accumulator(*accumulation.get(), t)); + } + else + { + accumulation.set(!!parent->seed ? parent->accumulator(*parent->seed.get(), t) : *parent->seeder(t).get()); + } + } + catch (...) + { + SinkBase::observer->OnError(std::current_exception()); + SinkBase::Dispose(); + return; + } + SinkBase::observer->OnNext(*accumulation.get()); + } + virtual void OnCompleted() + { + if (!accumulation && !!parent->seed) { + SinkBase::observer->OnNext(*parent->seed.get()); + } + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer ProducerBase; + public: + + ScanObservable(Source source, util::maybe seed, Accumulator accumulator, Seeder seeder) : + ProducerBase([this](Parent parent, std::shared_ptr < Observer < A >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(std::move(source)), + seed(std::move(seed)), + accumulator(std::move(accumulator)), + seeder(std::move(seeder)) + { + } + }; + } + template + std::shared_ptr> Scan( + const std::shared_ptr>& source, + A seed, + typename detail::ScanObservable::Accumulator accumulator + ) + { + return std::make_shared>( + std::move(source), + util::maybe(std::move(seed)), + std::move(accumulator), + [](T) -> util::maybe {abort(); return util::maybe();}); + } + template + std::shared_ptr> Scan( + const std::shared_ptr>& source, + typename detail::ScanObservable::Accumulator accumulator + ) + { + return std::make_shared>( + std::move(source), + util::maybe(), + std::move(accumulator), + [](T t) -> util::maybe {return util::maybe(t);}); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 9779d01..f4f8470 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -966,125 +966,11 @@ namespace rxcpp #include "operators/Publish.hpp" #include "operators/RefCount.hpp" #include "operators/ConnectForever.hpp" +#include "operators/Scan.hpp" namespace rxcpp { - namespace detail - { - template - class ScanObservable : public Producer, A> - { - typedef ScanObservable This; - typedef std::shared_ptr Parent; - typedef std::shared_ptr> Source; - typedef std::shared_ptr> Destination; - - public: - typedef std::function Accumulator; - typedef std::function(T)> Seeder; - - private: - - Source source; - util::maybe seed; - Accumulator accumulator; - Seeder seeder; - - class _ : public Sink<_, A>, public Observer - { - Parent parent; - util::maybe accumulation; - - public: - typedef Sink<_, A> SinkBase; - - _(Parent parent, Destination observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - virtual void OnNext(const T& t) - { - try - { - if (accumulation) - { - accumulation.set(parent->accumulator(*accumulation.get(), t)); - } - else - { - accumulation.set(!!parent->seed ? parent->accumulator(*parent->seed.get(), t) : *parent->seeder(t).get()); - } - } - catch (...) - { - SinkBase::observer->OnError(std::current_exception()); - SinkBase::Dispose(); - return; - } - SinkBase::observer->OnNext(*accumulation.get()); - } - virtual void OnCompleted() - { - if (!accumulation && !!parent->seed) { - SinkBase::observer->OnNext(*parent->seed.get()); - } - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer ProducerBase; - public: - - ScanObservable(Source source, util::maybe seed, Accumulator accumulator, Seeder seeder) : - ProducerBase([this](Parent parent, std::shared_ptr < Observer < A >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(std::move(source)), - seed(std::move(seed)), - accumulator(std::move(accumulator)), - seeder(std::move(seeder)) - { - } - }; - } - template - std::shared_ptr> Scan( - const std::shared_ptr>& source, - A seed, - typename detail::ScanObservable::Accumulator accumulator - ) - { - return std::make_shared>( - std::move(source), - util::maybe(std::move(seed)), - std::move(accumulator), - [](T) -> util::maybe {abort(); return util::maybe();}); - } - template - std::shared_ptr> Scan( - const std::shared_ptr>& source, - typename detail::ScanObservable::Accumulator accumulator - ) - { - return std::make_shared>( - std::move(source), - util::maybe(), - std::move(accumulator), - [](T t) -> util::maybe {return util::maybe(t);}); - } - template std::shared_ptr> Take( const std::shared_ptr>& source, -- GitLab From b7b94a2360f064e5d41cd0ef3d78733bc7ad6966 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:02:36 -0800 Subject: [PATCH 105/782] move Take to separate header --- Rx/CPP/src/cpprx/operators/Take.hpp | 147 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 135 +------------------------ 2 files changed, 148 insertions(+), 134 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Take.hpp diff --git a/Rx/CPP/src/cpprx/operators/Take.hpp b/Rx/CPP/src/cpprx/operators/Take.hpp new file mode 100644 index 0000000..8414394 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Take.hpp @@ -0,0 +1,147 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_TAKE_HPP) +#define CPPRX_RX_OPERATORS_TAKE_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> Take( + const std::shared_ptr>& source, + Integral n + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + // keep count of remaining calls received OnNext and count of OnNext calls issued. + auto remaining = std::make_shared, std::atomic>>(n, n); + + ComposableDisposable cd; + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + auto local = --std::get<0>(*remaining); + RXCPP_UNWIND_AUTO([&](){ + if (local >= 0){ + // all elements received + if (--std::get<1>(*remaining) == 0) { + // all elements passed on to observer. + observer->OnCompleted(); + cd.Dispose();}}}); + + if (local >= 0) { + observer->OnNext(element); + } + }, + // on completed + [=] + { + if (std::get<1>(*remaining) == 0 && std::get<0>(*remaining) <= 0) { + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } + + template + std::shared_ptr> TakeUntil( + const std::shared_ptr>& source, + const std::shared_ptr>& terminus + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + + struct TerminusState { + enum type { + Live, + Terminated + }; + }; + struct TakeState { + enum type { + Taking, + Completed + }; + }; + struct State { + State() : terminusState(TerminusState::Live), takeState(TakeState::Taking) {} + std::atomic terminusState; + std::atomic takeState; + }; + auto state = std::make_shared(); + + ComposableDisposable cd; + + cd.Add(Subscribe( + terminus, + // on next + [=](const T& element) + { + state->terminusState = TerminusState::Terminated; + }, + // on completed + [=] + { + state->terminusState = TerminusState::Terminated; + }, + // on error + [=](const std::exception_ptr& error) + { + state->terminusState = TerminusState::Terminated; + })); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (state->terminusState == TerminusState::Live) { + observer->OnNext(element); + } else if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on completed + [=] + { + if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { + state->terminusState = TerminusState::Terminated; + observer->OnCompleted(); + cd.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + state->takeState = TakeState::Completed; + state->terminusState = TerminusState::Terminated; + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index f4f8470..a625f23 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -967,144 +967,11 @@ namespace rxcpp #include "operators/RefCount.hpp" #include "operators/ConnectForever.hpp" #include "operators/Scan.hpp" +#include "operators/Take.hpp" namespace rxcpp { - template - std::shared_ptr> Take( - const std::shared_ptr>& source, - Integral n - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - // keep count of remaining calls received OnNext and count of OnNext calls issued. - auto remaining = std::make_shared, std::atomic>>(n, n); - - ComposableDisposable cd; - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - auto local = --std::get<0>(*remaining); - RXCPP_UNWIND_AUTO([&](){ - if (local >= 0){ - // all elements received - if (--std::get<1>(*remaining) == 0) { - // all elements passed on to observer. - observer->OnCompleted(); - cd.Dispose();}}}); - - if (local >= 0) { - observer->OnNext(element); - } - }, - // on completed - [=] - { - if (std::get<1>(*remaining) == 0 && std::get<0>(*remaining) <= 0) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } - - template - std::shared_ptr> TakeUntil( - const std::shared_ptr>& source, - const std::shared_ptr>& terminus - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - - struct TerminusState { - enum type { - Live, - Terminated - }; - }; - struct TakeState { - enum type { - Taking, - Completed - }; - }; - struct State { - State() : terminusState(TerminusState::Live), takeState(TakeState::Taking) {} - std::atomic terminusState; - std::atomic takeState; - }; - auto state = std::make_shared(); - - ComposableDisposable cd; - - cd.Add(Subscribe( - terminus, - // on next - [=](const T& element) - { - state->terminusState = TerminusState::Terminated; - }, - // on completed - [=] - { - state->terminusState = TerminusState::Terminated; - }, - // on error - [=](const std::exception_ptr& error) - { - state->terminusState = TerminusState::Terminated; - })); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - if (state->terminusState == TerminusState::Live) { - observer->OnNext(element); - } else if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on completed - [=] - { - if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { - state->terminusState = TerminusState::Terminated; - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - state->takeState = TakeState::Completed; - state->terminusState = TerminusState::Terminated; - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } - template std::shared_ptr> Skip( const std::shared_ptr>& source, -- GitLab From 7e2574c10fef68035d82a3afbeb79031789a62cd Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:06:06 -0800 Subject: [PATCH 106/782] move Skip to separate header --- Rx/CPP/src/cpprx/operators/Skip.hpp | 132 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 121 +------------------------ 2 files changed, 133 insertions(+), 120 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Skip.hpp diff --git a/Rx/CPP/src/cpprx/operators/Skip.hpp b/Rx/CPP/src/cpprx/operators/Skip.hpp new file mode 100644 index 0000000..fb27dbb --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Skip.hpp @@ -0,0 +1,132 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_SKIP_HPP) +#define CPPRX_RX_OPERATORS_SKIP_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> Skip( + const std::shared_ptr>& source, + Integral n + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + enum type { + Skipping, + Forwarding + }; + }; + // keep count of remaining OnNext calls to skip and state. + auto remaining = std::make_shared, std::atomic>>(n, State::Skipping); + + ComposableDisposable cd; + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (std::get<1>(*remaining) == State::Forwarding) { + observer->OnNext(element); + } else { + auto local = --std::get<0>(*remaining); + + if (local == 0) { + std::get<1>(*remaining) = State::Forwarding; + } + } + }, + // on completed + [=] + { + observer->OnCompleted(); + cd.Dispose(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } + + template + std::shared_ptr> SkipUntil( + const std::shared_ptr>& source, + const std::shared_ptr>& terminus + ) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct SkipState { + enum type { + Skipping, + Taking + }; + }; + struct State { + State() : skipState(SkipState::Skipping) {} + std::atomic skipState; + }; + auto state = std::make_shared(); + + ComposableDisposable cd; + + cd.Add(Subscribe( + terminus, + // on next + [=](const T& element) + { + state->skipState = SkipState::Taking; + }, + // on completed + [=] + { + state->skipState = SkipState::Taking; + }, + // on error + [=](const std::exception_ptr& error) + { + state->skipState = SkipState::Taking; + })); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + if (state->skipState == SkipState::Taking) { + observer->OnNext(element); + } + }, + // on completed + [=] + { + observer->OnCompleted(); + cd.Dispose(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index a625f23..07d445b 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -968,130 +968,11 @@ namespace rxcpp #include "operators/ConnectForever.hpp" #include "operators/Scan.hpp" #include "operators/Take.hpp" +#include "operators/Skip.hpp" namespace rxcpp { - template - std::shared_ptr> Skip( - const std::shared_ptr>& source, - Integral n - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - enum type { - Skipping, - Forwarding - }; - }; - // keep count of remaining OnNext calls to skip and state. - auto remaining = std::make_shared, std::atomic>>(n, State::Skipping); - - ComposableDisposable cd; - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - if (std::get<1>(*remaining) == State::Forwarding) { - observer->OnNext(element); - } else { - auto local = --std::get<0>(*remaining); - - if (local == 0) { - std::get<1>(*remaining) = State::Forwarding; - } - } - }, - // on completed - [=] - { - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } - - template - std::shared_ptr> SkipUntil( - const std::shared_ptr>& source, - const std::shared_ptr>& terminus - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct SkipState { - enum type { - Skipping, - Taking - }; - }; - struct State { - State() : skipState(SkipState::Skipping) {} - std::atomic skipState; - }; - auto state = std::make_shared(); - - ComposableDisposable cd; - - cd.Add(Subscribe( - terminus, - // on next - [=](const T& element) - { - state->skipState = SkipState::Taking; - }, - // on completed - [=] - { - state->skipState = SkipState::Taking; - }, - // on error - [=](const std::exception_ptr& error) - { - state->skipState = SkipState::Taking; - })); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - if (state->skipState == SkipState::Taking) { - observer->OnNext(element); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } - - template std::shared_ptr> ToStdCollection( const std::shared_ptr>& source -- GitLab From 888bcd5f45ed6c0bad3895d74aedd771a246b7f9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:32:14 -0800 Subject: [PATCH 107/782] move Delay to separate header --- Rx/CPP/src/cpprx/operators/Delay.hpp | 79 ++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 75 +++----------------------- 2 files changed, 85 insertions(+), 69 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Delay.hpp diff --git a/Rx/CPP/src/cpprx/operators/Delay.hpp b/Rx/CPP/src/cpprx/operators/Delay.hpp new file mode 100644 index 0000000..fe55f70 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Delay.hpp @@ -0,0 +1,79 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_DELAY_HPP) +#define CPPRX_RX_OPERATORS_DELAY_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> Delay( + const std::shared_ptr>& source, + Scheduler::clock::duration due, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + auto cancel = std::make_shared(false); + + ComposableDisposable cd; + + cd.Add(Disposable([=]{ + *cancel = true; })); + + SerialDisposable sd; + auto wsd = cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + auto sched_disposable = scheduler->Schedule( + due, + [=] (Scheduler::shared) -> Disposable { + if (!*cancel) + observer->OnNext(element); + return Disposable::Empty(); + } + ); + auto ssd = wsd.lock(); + if (ssd) + { + *ssd.get() = std::move(sched_disposable); + } + }, + // on completed + [=] + { + auto sched_disposable = scheduler->Schedule( + due, + [=](Scheduler::shared) -> Disposable { + if (!*cancel) + observer->OnCompleted(); + return Disposable::Empty(); + } + ); + auto ssd = wsd.lock(); + if (ssd) + { + *ssd.get() = std::move(sched_disposable); + } + }, + // on error + [=](const std::exception_ptr& error) + { + if (!*cancel) + observer->OnError(error); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 07d445b..39fe839 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -970,6 +970,12 @@ namespace rxcpp #include "operators/Take.hpp" #include "operators/Skip.hpp" +////////////////////////////////////////////////////////////////////// +// +// time + +#include "operators/Delay.hpp" + namespace rxcpp { @@ -1004,75 +1010,6 @@ namespace rxcpp }); } - ////////////////////////////////////////////////////////////////////// - // - // time - - template - std::shared_ptr> Delay( - const std::shared_ptr>& source, - Scheduler::clock::duration due, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - *cancel = true; })); - - SerialDisposable sd; - auto wsd = cd.Add(sd); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - auto sched_disposable = scheduler->Schedule( - due, - [=] (Scheduler::shared) -> Disposable { - if (!*cancel) - observer->OnNext(element); - return Disposable::Empty(); - } - ); - auto ssd = wsd.lock(); - if (ssd) - { - *ssd.get() = std::move(sched_disposable); - } - }, - // on completed - [=] - { - auto sched_disposable = scheduler->Schedule( - due, - [=](Scheduler::shared) -> Disposable { - if (!*cancel) - observer->OnCompleted(); - return Disposable::Empty(); - } - ); - auto ssd = wsd.lock(); - if (ssd) - { - *ssd.get() = std::move(sched_disposable); - } - }, - // on error - [=](const std::exception_ptr& error) - { - if (!*cancel) - observer->OnError(error); - })); - return cd; - }); - } template std::shared_ptr> Throttle( -- GitLab From e08cc09ca1079b31554eeed7400e564080d5e026 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:35:10 -0800 Subject: [PATCH 108/782] move Throttle to separate header --- Rx/CPP/src/cpprx/operators/Throttle.hpp | 97 +++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 86 +--------------------- 2 files changed, 98 insertions(+), 85 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Throttle.hpp diff --git a/Rx/CPP/src/cpprx/operators/Throttle.hpp b/Rx/CPP/src/cpprx/operators/Throttle.hpp new file mode 100644 index 0000000..89abdd1 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Throttle.hpp @@ -0,0 +1,97 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_THROTTLE_HPP) +#define CPPRX_RX_OPERATORS_THROTTLE_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> Throttle( + const std::shared_ptr>& source, + Scheduler::clock::duration due, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + State() : hasValue(false), id(0) {} + std::mutex lock; + T value; + bool hasValue; + size_t id; + }; + auto state = std::make_shared(); + + ComposableDisposable cd; + + SerialDisposable sd; + cd.Add(sd); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + size_t current = 0; + { + std::unique_lock guard(state->lock); + state->hasValue = true; + state->value = std::move(element); + current = ++state->id; + } + sd.Set(scheduler->Schedule( + due, + [=] (Scheduler::shared) -> Disposable { + { + std::unique_lock guard(state->lock); + if (state->hasValue && state->id == current) { + observer->OnNext(std::move(state->value)); + } + state->hasValue = false; + } + + return Disposable::Empty(); + } + )); + }, + // on completed + [=] + { + bool sendValue = false; + T value; + { + std::unique_lock guard(state->lock); + sendValue = state->hasValue; + if (sendValue) { + value = std::move(state->value);} + state->hasValue = false; + ++state->id; + } + if (sendValue) { + observer->OnNext(std::move(value));} + observer->OnCompleted(); + cd.Dispose(); + }, + // on error + [=](const std::exception_ptr& error) + { + { + std::unique_lock guard(state->lock); + state->hasValue = false; + ++state->id; + } + observer->OnError(error); + cd.Dispose(); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 39fe839..df38391 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -975,6 +975,7 @@ namespace rxcpp // time #include "operators/Delay.hpp" +#include "operators/Throttle.hpp" namespace rxcpp { @@ -1011,91 +1012,6 @@ namespace rxcpp } - template - std::shared_ptr> Throttle( - const std::shared_ptr>& source, - Scheduler::clock::duration due, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - State() : hasValue(false), id(0) {} - std::mutex lock; - T value; - bool hasValue; - size_t id; - }; - auto state = std::make_shared(); - - ComposableDisposable cd; - - SerialDisposable sd; - cd.Add(sd); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - size_t current = 0; - { - std::unique_lock guard(state->lock); - state->hasValue = true; - state->value = std::move(element); - current = ++state->id; - } - sd.Set(scheduler->Schedule( - due, - [=] (Scheduler::shared) -> Disposable { - { - std::unique_lock guard(state->lock); - if (state->hasValue && state->id == current) { - observer->OnNext(std::move(state->value)); - } - state->hasValue = false; - } - - return Disposable::Empty(); - } - )); - }, - // on completed - [=] - { - bool sendValue = false; - T value; - { - std::unique_lock guard(state->lock); - sendValue = state->hasValue; - if (sendValue) { - value = std::move(state->value);} - state->hasValue = false; - ++state->id; - } - if (sendValue) { - observer->OnNext(std::move(value));} - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - { - std::unique_lock guard(state->lock); - state->hasValue = false; - ++state->id; - } - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } - - // no more than one event ever 'milliseconds' // TODO: oops, this is not the right definition for throttle. template -- GitLab From 9c45683050f4ad3342edbfa871f614a5a0bc483b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:52:07 -0800 Subject: [PATCH 109/782] move DistinctUntilChanged to separate header --- .../cpprx/operators/DistinctUntilChanged.hpp | 55 +++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 41 +------------- 2 files changed, 56 insertions(+), 40 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp diff --git a/Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp b/Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp new file mode 100644 index 0000000..1796ed9 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp @@ -0,0 +1,55 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_DISTINCTUNTILCHANGED_HPP) +#define CPPRX_RX_OPERATORS_DISTINCTUNTILCHANGED_HPP + +namespace rxcpp +{ + + // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 + template + std::shared_ptr> DistinctUntilChanged( + const std::shared_ptr>& source) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + struct State { + State() : last(), hasValue(false) {} + T last; bool hasValue; + }; + + auto state = std::make_shared(); + state->hasValue = false; + + return Subscribe( + source, + // on next + [=](const T& element) + { + if (!state->hasValue || !(state->last == element)) + { + observer->OnNext(element); + state->last = element; + state->hasValue = true; + } + }, + // on completed + [=] + { + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index df38391..e8bf5a8 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -969,6 +969,7 @@ namespace rxcpp #include "operators/Scan.hpp" #include "operators/Take.hpp" #include "operators/Skip.hpp" +#include "operators/DistinctUntilChanged.hpp" ////////////////////////////////////////////////////////////////////// // @@ -1058,47 +1059,7 @@ namespace rxcpp }); } - // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 - template - std::shared_ptr> DistinctUntilChanged( - const std::shared_ptr>& source) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - State() : last(), hasValue(false) {} - T last; bool hasValue; - }; - - auto state = std::make_shared(); - state->hasValue = false; - return Subscribe( - source, - // on next - [=](const T& element) - { - if (!state->hasValue || !(state->last == element)) - { - observer->OnNext(element); - state->last = element; - state->hasValue = true; - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } template std::shared_ptr> SubscribeOnObservable( -- GitLab From 1403831e2a62f6bf6cb67644951dbcddf3fd7739 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:52:50 -0800 Subject: [PATCH 110/782] move ToStdCollection to separate header --- .../src/cpprx/operators/ToStdCollection.hpp | 44 +++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 33 +------------- 2 files changed, 45 insertions(+), 32 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/ToStdCollection.hpp diff --git a/Rx/CPP/src/cpprx/operators/ToStdCollection.hpp b/Rx/CPP/src/cpprx/operators/ToStdCollection.hpp new file mode 100644 index 0000000..25813b1 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/ToStdCollection.hpp @@ -0,0 +1,44 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_TOSTDCOLLECTION_HPP) +#define CPPRX_RX_OPERATORS_TOSTDCOLLECTION_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> ToStdCollection( + const std::shared_ptr>& source + ) + { + typedef typename StdCollection::value_type Value; + return CreateObservable( + [=](std::shared_ptr> observer) -> Disposable + { + auto stdCollection = std::make_shared(); + return Subscribe( + source, + // on next + [=](const Value& element) + { + stdCollection->insert(stdCollection->end(), element); + }, + // on completed + [=] + { + observer->OnNext(std::move(*stdCollection.get())); + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(error); + }); + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index e8bf5a8..db441f0 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -970,6 +970,7 @@ namespace rxcpp #include "operators/Take.hpp" #include "operators/Skip.hpp" #include "operators/DistinctUntilChanged.hpp" +#include "operators/ToStdCollection.hpp" ////////////////////////////////////////////////////////////////////// // @@ -981,38 +982,6 @@ namespace rxcpp namespace rxcpp { - template - std::shared_ptr> ToStdCollection( - const std::shared_ptr>& source - ) - { - typedef typename StdCollection::value_type Value; - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - auto stdCollection = std::make_shared(); - return Subscribe( - source, - // on next - [=](const Value& element) - { - stdCollection->insert(stdCollection->end(), element); - }, - // on completed - [=] - { - observer->OnNext(std::move(*stdCollection.get())); - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - // no more than one event ever 'milliseconds' // TODO: oops, this is not the right definition for throttle. template -- GitLab From 79c1d5f07d831081a361cc72f8ddf98564754dd5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 14:57:48 -0800 Subject: [PATCH 111/782] move SubscribeOnObservable to separate header --- .../cpprx/operators/SubscribeOnObservable.hpp | 35 +++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 30 +++++----------- 2 files changed, 43 insertions(+), 22 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp diff --git a/Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp b/Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp new file mode 100644 index 0000000..29a4c6b --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp @@ -0,0 +1,35 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_SUBSCRIBEONOBSERVABLE_HPP) +#define CPPRX_RX_OPERATORS_SUBSCRIBEONOBSERVABLE_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> SubscribeOnObservable( + const std::shared_ptr>& source, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observer) + -> Disposable + { + ComposableDisposable cd; + + SerialDisposable sd; + cd.Add(sd); + + cd.Add(scheduler->Schedule([=](Scheduler::shared) -> Disposable { + sd.Set(ScheduledDisposable(scheduler, source->Subscribe(observer))); + return Disposable::Empty(); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index db441f0..ea4e58b 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -972,6 +972,14 @@ namespace rxcpp #include "operators/DistinctUntilChanged.hpp" #include "operators/ToStdCollection.hpp" + +////////////////////////////////////////////////////////////////////// +// +// shift to Scheduler + +#include "operators/SubscribeOnObservable.hpp" + + ////////////////////////////////////////////////////////////////////// // // time @@ -1030,28 +1038,6 @@ namespace rxcpp - template - std::shared_ptr> SubscribeOnObservable( - const std::shared_ptr>& source, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - ComposableDisposable cd; - - SerialDisposable sd; - cd.Add(sd); - - cd.Add(scheduler->Schedule([=](Scheduler::shared) -> Disposable { - sd.Set(ScheduledDisposable(scheduler, source->Subscribe(observer))); - return Disposable::Empty(); - })); - return cd; - }); - } - template std::shared_ptr> ObserveOnObserver( const std::shared_ptr>& source, -- GitLab From 5a188416562193585c633c93d033b20213e43c7f Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 15:02:16 -0800 Subject: [PATCH 112/782] move ObserveOnObserver to separate header --- .../src/cpprx/operators/ObserveOnObserver.hpp | 53 +++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 42 +-------------- 2 files changed, 54 insertions(+), 41 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp diff --git a/Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp b/Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp new file mode 100644 index 0000000..4ff79f7 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp @@ -0,0 +1,53 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_OBSERVEONOBSERVER_HPP) +#define CPPRX_RX_OPERATORS_OBSERVEONOBSERVER_HPP + +namespace rxcpp +{ + + template + std::shared_ptr> ObserveOnObserver( + const std::shared_ptr>& source, + Scheduler::shared scheduler) + { + return CreateObservable( + [=](std::shared_ptr> observerArg) + -> Disposable + { + std::shared_ptr> observer( + new ScheduledObserver(scheduler, std::move(observerArg))); + + ComposableDisposable cd; + + cd.Add(*observer.get()); + + cd.Add(Subscribe( + source, + // on next + [=](const T& element) + { + observer->OnNext(std::move(element)); + observer->EnsureActive(); + }, + // on completed + [=] + { + observer->OnCompleted(); + observer->EnsureActive(); + }, + // on error + [=](const std::exception_ptr& error) + { + observer->OnError(std::move(error)); + observer->EnsureActive(); + })); + return cd; + }); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index ea4e58b..fb64e2a 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -978,6 +978,7 @@ namespace rxcpp // shift to Scheduler #include "operators/SubscribeOnObservable.hpp" +#include "operators/ObserveOnObserver.hpp" ////////////////////////////////////////////////////////////////////// @@ -1037,47 +1038,6 @@ namespace rxcpp } - - template - std::shared_ptr> ObserveOnObserver( - const std::shared_ptr>& source, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observerArg) - -> Disposable - { - std::shared_ptr> observer( - new ScheduledObserver(scheduler, std::move(observerArg))); - - ComposableDisposable cd; - - cd.Add(*observer.get()); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - observer->OnNext(std::move(element)); - observer->EnsureActive(); - }, - // on completed - [=] - { - observer->OnCompleted(); - observer->EnsureActive(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(std::move(error)); - observer->EnsureActive(); - })); - return cd; - }); - } - class StdQueueDispatcher { mutable std::queue> pending; -- GitLab From 973667169ada8d7ea5c5c56100493d48ba0eddba Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 15:06:39 -0800 Subject: [PATCH 113/782] move ToAsync to separate header --- Rx/CPP/src/cpprx/operators/ToAsync.hpp | 48 ++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 36 +------------------ 2 files changed, 49 insertions(+), 35 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/ToAsync.hpp diff --git a/Rx/CPP/src/cpprx/operators/ToAsync.hpp b/Rx/CPP/src/cpprx/operators/ToAsync.hpp new file mode 100644 index 0000000..33bffcb --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/ToAsync.hpp @@ -0,0 +1,48 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_TOASYNC_HPP) +#define CPPRX_RX_OPERATORS_TOASYNC_HPP + +namespace rxcpp +{ + +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto ToAsync(F f, Scheduler::shared scheduler = nullptr) + ->std::function < std::shared_ptr < Observable< decltype(f((*(A*)nullptr)...)) >> (const A&...)> + { + typedef decltype(f((*(A*) nullptr)...)) R; + if (!scheduler) + { + scheduler = std::make_shared(); + } + return [=](const A&... a) -> std::shared_ptr < Observable> + { + auto args = std::make_tuple(a...); + auto result = CreateAsyncSubject(); + scheduler->Schedule([=](Scheduler::shared) -> Disposable + { + util::maybe value; + try + { + value.set(util::tuple_dispatch(f, args)); + } + catch (...) + { + result->OnError(std::current_exception()); + return Disposable::Empty(); + } + result->OnNext(*value.get()); + result->OnCompleted(); + return Disposable::Empty(); + }); + return result; + }; + } +#endif +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index fb64e2a..1e90a0c 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -789,41 +789,6 @@ namespace rxcpp return std::make_shared>(); } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto ToAsync(F f, Scheduler::shared scheduler = nullptr) - ->std::function < std::shared_ptr < Observable< decltype(f((*(A*)nullptr)...)) >> (const A&...)> - { - typedef decltype(f((*(A*) nullptr)...)) R; - if (!scheduler) - { - scheduler = std::make_shared(); - } - return [=](const A&... a) -> std::shared_ptr < Observable> - { - auto args = std::make_tuple(a...); - auto result = CreateAsyncSubject(); - scheduler->Schedule([=](Scheduler::shared) -> Disposable - { - util::maybe value; - try - { - value.set(util::tuple_dispatch(f, args)); - } - catch (...) - { - result->OnError(std::current_exception()); - return Disposable::Empty(); - } - result->OnNext(*value.get()); - result->OnCompleted(); - return Disposable::Empty(); - }); - return result; - }; - } -#endif - template class ConnectableSubject : public std::enable_shared_from_this>, @@ -971,6 +936,7 @@ namespace rxcpp #include "operators/Skip.hpp" #include "operators/DistinctUntilChanged.hpp" #include "operators/ToStdCollection.hpp" +#include "operators/ToAsync.hpp" ////////////////////////////////////////////////////////////////////// -- GitLab From 4c44dfa9445278f2cd791eea575708b401bc03a4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 15:10:06 -0800 Subject: [PATCH 114/782] move ForEach to separate header --- Rx/CPP/src/cpprx/operators/ForEach.hpp | 49 ++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 44 +++-------------------- 2 files changed, 54 insertions(+), 39 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/ForEach.hpp diff --git a/Rx/CPP/src/cpprx/operators/ForEach.hpp b/Rx/CPP/src/cpprx/operators/ForEach.hpp new file mode 100644 index 0000000..e2c815e --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/ForEach.hpp @@ -0,0 +1,49 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_FOREACH_HPP) +#define CPPRX_RX_OPERATORS_FOREACH_HPP + +namespace rxcpp +{ + + template + void ForEach( + const std::shared_ptr>& source, + typename util::identity>::type onNext + ) + { + std::mutex lock; + std::condition_variable wake; + bool done = false; + std::exception_ptr error; + auto observer = CreateObserver(std::move(onNext), + //on completed + [&]{ + std::unique_lock guard(lock); + done = true; + wake.notify_one(); + }, + //on error + [&](const std::exception_ptr& e){ + std::unique_lock guard(lock); + done = true; + error = std::move(e); + wake.notify_one(); + }); + + source->Subscribe(observer); + + { + std::unique_lock guard(lock); + wake.wait(guard, [&]{return done;}); + } + + if (error != std::exception_ptr()) { + std::rethrow_exception(error);} + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 1e90a0c..1e04ded 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -851,9 +851,6 @@ namespace rxcpp return fix0_thunk(std::move(f)); } - ////////////////////////////////////////////////////////////////////// - // - // imperative functions template Disposable Subscribe( @@ -868,44 +865,12 @@ namespace rxcpp return source->Subscribe(observer); } - - template - void ForEach( - const std::shared_ptr>& source, - typename util::identity>::type onNext - ) - { - std::mutex lock; - std::condition_variable wake; - bool done = false; - std::exception_ptr error; - auto observer = CreateObserver(std::move(onNext), - //on completed - [&]{ - std::unique_lock guard(lock); - done = true; - wake.notify_one(); - }, - //on error - [&](const std::exception_ptr& e){ - std::unique_lock guard(lock); - done = true; - error = std::move(e); - wake.notify_one(); - }); - - source->Subscribe(observer); - - { - std::unique_lock guard(lock); - wake.wait(guard, [&]{return done;}); - } - - if (error != std::exception_ptr()) { - std::rethrow_exception(error);} - } } +////////////////////////////////////////////////////////////////////// +// +// imperative functions + #include "operators/Empty.hpp" #include "operators/Return.hpp" #include "operators/Throw.hpp" @@ -919,6 +884,7 @@ namespace rxcpp // // standard query operators +#include "operators/ForEach.hpp" #include "operators/Select.hpp" #include "operators/SelectMany.hpp" #include "operators/Concat.hpp" -- GitLab From fa6d9c00f13e177028b71027438a656713526b5a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 24 Nov 2013 15:12:41 -0800 Subject: [PATCH 115/782] move Subscribe to separate header --- Rx/CPP/src/cpprx/operators/Subscribe.hpp | 27 ++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 18 ++-------------- 2 files changed, 29 insertions(+), 16 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Subscribe.hpp diff --git a/Rx/CPP/src/cpprx/operators/Subscribe.hpp b/Rx/CPP/src/cpprx/operators/Subscribe.hpp new file mode 100644 index 0000000..5717720 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Subscribe.hpp @@ -0,0 +1,27 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_SUBSCRIBE_HPP) +#define CPPRX_RX_OPERATORS_SUBSCRIBE_HPP + +namespace rxcpp +{ + + template + Disposable Subscribe( + const S& source, + typename util::identity::type&)>>::type onNext, + std::function onCompleted = nullptr, + std::function onError = nullptr + ) + { + auto observer = CreateObserver::type>( + std::move(onNext), std::move(onCompleted), std::move(onError)); + + return source->Subscribe(observer); + } +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 1e04ded..a8e5cad 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -850,27 +850,14 @@ namespace rxcpp { return fix0_thunk(std::move(f)); } - - - template - Disposable Subscribe( - const S& source, - typename util::identity::type&)>>::type onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) - { - auto observer = CreateObserver::type>( - std::move(onNext), std::move(onCompleted), std::move(onError)); - - return source->Subscribe(observer); - } } ////////////////////////////////////////////////////////////////////// // // imperative functions +#include "operators/Subscribe.hpp" +#include "operators/ForEach.hpp" #include "operators/Empty.hpp" #include "operators/Return.hpp" #include "operators/Throw.hpp" @@ -884,7 +871,6 @@ namespace rxcpp // // standard query operators -#include "operators/ForEach.hpp" #include "operators/Select.hpp" #include "operators/SelectMany.hpp" #include "operators/Concat.hpp" -- GitLab From 8bcc30f0e61ff2ea2c2f05c455fa4ae5802b7614 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 30 Nov 2013 20:53:34 -0800 Subject: [PATCH 116/782] Add Materialize and Dematerialize --- Rx/CPP/src/cpprx/operators/Dematerialize.hpp | 93 ++++++++++++++++++++ Rx/CPP/src/cpprx/operators/Materialize.hpp | 87 ++++++++++++++++++ Rx/CPP/src/cpprx/rx-base.hpp | 84 ++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 2 + Rx/CPP/src/cpprx/rx.hpp | 45 +++++++++- Rx/CPP/testbench/testbench.cpp | 2 + 6 files changed, 311 insertions(+), 2 deletions(-) create mode 100644 Rx/CPP/src/cpprx/operators/Dematerialize.hpp create mode 100644 Rx/CPP/src/cpprx/operators/Materialize.hpp diff --git a/Rx/CPP/src/cpprx/operators/Dematerialize.hpp b/Rx/CPP/src/cpprx/operators/Dematerialize.hpp new file mode 100644 index 0000000..796a133 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Dematerialize.hpp @@ -0,0 +1,93 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_DEMATERIALIZE_HPP) +#define CPPRX_RX_OPERATORS_DEMATERIALIZE_HPP + +namespace rxcpp +{ + +namespace detail +{ + +template +class DematerializeObservable : public Producer, T> +{ + typedef DematerializeObservable This; + typedef std::shared_ptr Parent; + typedef std::shared_ptr>>> Source; + typedef std::shared_ptr> Destination; + +private: + + Source source; + + class _ : public Sink<_, T>, public Observer>> + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, Destination observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + virtual void OnNext(const std::shared_ptr>& n) + { + n->Accept([this](const T& t){ + this->SinkBase::observer->OnNext(t); + }, [this](){ + this->SinkBase::observer->OnCompleted(); + this->SinkBase::Dispose(); + }, [this](const std::exception_ptr& e){ + this->SinkBase::observer->OnError(e); + this->SinkBase::Dispose(); + }); + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer ProducerBase; +public: + + DematerializeObservable(Source source) : + ProducerBase([this](Parent parent, Destination observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(std::move(source)) + { + } +}; + +} + +template +std::shared_ptr> Dematerialize( + const std::shared_ptr>>>& source +) +{ + return std::make_shared>( + std::move(source) + ); +} + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Materialize.hpp b/Rx/CPP/src/cpprx/operators/Materialize.hpp new file mode 100644 index 0000000..ede4d6e --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Materialize.hpp @@ -0,0 +1,87 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_MATERIALIZE_HPP) +#define CPPRX_RX_OPERATORS_MATERIALIZE_HPP + +namespace rxcpp +{ + +namespace detail +{ + +template +class MaterializeObservable : public Producer, std::shared_ptr>> +{ + typedef MaterializeObservable This; + typedef std::shared_ptr Parent; + typedef std::shared_ptr> Source; + typedef std::shared_ptr>>> Destination; + +private: + + Source source; + + class _ : public Sink<_, std::shared_ptr>>, public Observer + { + Parent parent; + + public: + typedef Sink<_, std::shared_ptr>> SinkBase; + + _(Parent parent, Destination observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + virtual void OnNext(const T& t) + { + SinkBase::observer->OnNext(Notification::CreateOnNext(t)); + } + virtual void OnCompleted() + { + SinkBase::observer->OnNext(Notification::CreateOnCompleted()); + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnNext(Notification::CreateOnError(e)); + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + }; + + typedef Producer>> ProducerBase; +public: + + MaterializeObservable(Source source) : + ProducerBase([this](Parent parent, Destination observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(std::move(source)) + { + } +}; + +} + +template +std::shared_ptr>>> Materialize( + const std::shared_ptr>& source +) +{ + return std::make_shared>( + std::move(source) + ); +} + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 1ad3966..8dec099 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -356,6 +356,90 @@ namespace rxcpp } }; + template + struct Notification { + typedef std::function OnNext; + typedef std::function OnCompleted; + typedef std::function OnError; + + virtual ~Notification() {} + + virtual void Accept(std::shared_ptr>) =0; + virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) =0; + + private: + struct OnNextNotification : public Notification { + OnNextNotification(T value) : value(std::move(value)) { + } + virtual void Accept(std::shared_ptr> o) { + if (!o) { + abort(); + } + o->OnNext(value); + } + virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) { + if (!onnext || !oncompleted || !onerror) { + abort(); + } + onnext(value); + } + const T value; + }; + + struct OnCompletedNotification : public Notification { + OnCompletedNotification() { + } + virtual void Accept(std::shared_ptr> o) { + if (!o) { + abort(); + } + o->OnCompleted(); + } + virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) { + if (!onnext || !oncompleted || !onerror) { + abort(); + } + oncompleted(); + } + }; + + struct OnErrorNotification : public Notification { + OnErrorNotification(std::exception_ptr ep) : ep(ep) { + } + virtual void Accept(std::shared_ptr> o) { + if (!o) { + abort(); + } + o->OnError(ep); + } + virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) { + if (!onnext || !oncompleted || !onerror) { + abort(); + } + onerror(ep); + } + const std::exception_ptr ep; + }; + + public: + static + std::shared_ptr CreateOnNext(T value) { + return std::make_shared(std::move(value)); + } + static + std::shared_ptr CreateOnCompleted() { + return std::make_shared(); + } + template + static + std::shared_ptr CreateOnError(Exception&& e) { + std::exception_ptr ep; + try {throw std::forward(e);} + catch (...) {ep = std::current_exception();} + return std::make_shared(ep); + } + }; + template class TupleDispatch { Target target; diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index a8e5cad..fabb763 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -889,6 +889,8 @@ namespace rxcpp #include "operators/DistinctUntilChanged.hpp" #include "operators/ToStdCollection.hpp" #include "operators/ToAsync.hpp" +#include "operators/Materialize.hpp" +#include "operators/Dematerialize.hpp" ////////////////////////////////////////////////////////////////////// diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index 3835a3c..ade931f 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -123,10 +123,43 @@ namespace detail { } }; + template + class BinderMaterialized : public Base + { + protected: + typedef typename Base::item_type item_type; + using Base::obj; + public: + BinderMaterialized(Obj obj) : Base(std::move(obj)) + { + } + }; + + template + class BinderMaterialized>>>> : public Base + { + protected: + typedef typename Base::item_type item_type; + using Base::obj; + public: + BinderMaterialized(std::shared_ptr>>> obj) : Base(std::move(obj)) + { + } + + auto dematerialize() + -> decltype(from(Dematerialize(observable(obj)))) { + return from(Dematerialize(observable(obj))); + } + }; + template class Binder : public BinderNested< BinderConnectable< - BinderBase::type, Obj>, + BinderMaterialized< + BinderBase::type, Obj>, + typename observable_item::type, + Obj + >, typename observable_item::type, Obj >, @@ -136,7 +169,11 @@ namespace detail { { typedef BinderNested< BinderConnectable< - BinderBase::type, Obj>, + BinderMaterialized< + BinderBase::type, Obj>, + typename observable_item::type, + Obj + >, typename observable_item::type, Obj >, @@ -343,6 +380,10 @@ namespace detail { -> decltype(from(ToStdCollection>(obj))) { return from(ToStdCollection>(obj)); } + auto materialize() + -> decltype(from(Materialize(observable(obj)))) { + return from(Materialize(observable(obj))); + } auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { return from(Delay(obj, due, scheduler)); } diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 6aaee53..2e41f4d 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -51,6 +51,8 @@ void PrintPrimes(int n) auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers rxcpp::from(values) .where(IsPrime) + .materialize() + .dematerialize() .select([](int x) { return std::make_pair(x, x*x); }) .take(n) .for_each(rxcpp::MakeTupleDispatch( -- GitLab From 596c281ab686237837540d456c387b970e7cf7a7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 30 Nov 2013 22:30:25 -0800 Subject: [PATCH 117/782] Add VirtualTimeSchedulerBase --- Rx/CPP/src/cpprx/rx-base.hpp | 169 ++++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-scheduler.hpp | 9 +- 2 files changed, 170 insertions(+), 8 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 8dec099..945e8de 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -356,6 +356,175 @@ namespace rxcpp } }; + template + struct ScheduledItem { + ScheduledItem(Absolute due, std::shared_ptr work) + : due(due) + , work(std::move(work)) + {} + Absolute due; + std::shared_ptr work; + }; + + template + struct VirtualTimeSchedulerBase : public Scheduler + { + private: + VirtualTimeSchedulerBase(const VirtualTimeSchedulerBase&); + + bool is_enabled; + + public: + static void Do(Work& work, Scheduler::shared scheduler) throw() + { + if (work) + { + work(std::move(scheduler)); + } + } + + public: + VirtualTimeSchedulerBase() + : is_enabled(false) + { + } + explicit VirtualTimeSchedulerBase(Absolute initialClock) + : is_enabled(false) + , clock_now(initialClock) + { + } + virtual ~VirtualTimeSchedulerBase() + { + } + + protected: + Absolute clock_now; + + virtual Absolute Add(Absolute, Relative) =0; + + virtual clock::time_point ToTimePoint(Absolute) =0; + virtual Relative ToRelative(clock::duration) =0; + + virtual ScheduledItem GetNext() =0; + + public: + virtual Disposable ScheduleAbsolute(Absolute, Work) =0; + + virtual Disposable ScheduleRelative(Relative dueTime, Work work) { + auto at = Add(clock_now, dueTime); + return ScheduleAbsolute(at, std::move(work)); + } + + virtual clock::time_point Now() {return ToAbsolute(clock_now);} + + bool IsEnabled() {return is_enabled;} + Absolute Clock() {return clock_now;} + + using Scheduler::Schedule; + virtual Disposable Schedule(Work work) + { + return ScheduleAbsolute(clock_now, std::move(work)); + } + + virtual Disposable Schedule(clock::duration due, Work work) + { + return ScheduleRelative(ToRelative(due), std::move(work)); + } + + virtual Disposable Schedule(clock::time_point due, Work work) + { + return ScheduleRelative(ToRelative(due - Now()), std::move(work)); + } + + void Start() + { + if (!is_enabled) { + is_enabled = true; + do { + auto next = GetNext(); + if (!!next.work) { + if (next.due > clock_now) { + clock_now = next.due; + } + Do(next.work, this); + } + else { + is_enabled = false; + } + } while (is_enabled); + } + } + + void Stop() + { + is_enabled = false; + } + + void AdvanceTo(Absolute time) + { + if (time < clock_now) { + abort(); + } + + if (time == clock_now) { + return; + } + + if (!is_enabled) { + is_enabled = true; + do { + auto next = GetNext(); + if (!!next.work && next.due <= time) { + if (next.due > clock_now) { + clock_now = next.due; + } + Do(next.work, this); + } + else { + is_enabled = false; + } + } while (is_enabled); + + clock_now = time; + } + else { + abort(); + } + } + + void AdvanceBy(Relative time) + { + auto dt = Add(clock_now, time); + + if (dt < clock_now) { + abort(); + } + + if (dt == clock_now) { + return; + } + + if (!is_enabled) { + AdvanceTo(dt); + } + else { + abort(); + } + } + + void Sleep(Relative time) + { + auto dt = Add(clock_now, time); + + if (dt < clock_now) { + abort(); + } + + clock_now = dt; + } + + }; + template struct Notification { typedef std::function OnNext; diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index ca72835..293eb5c 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -17,14 +17,7 @@ namespace rxcpp { typedef Scheduler::clock clock; typedef Scheduler::Work Work; - struct QueueItem { - QueueItem(clock::time_point due, std::shared_ptr work) - : due(due) - , work(std::move(work)) - {} - clock::time_point due; - std::shared_ptr work; - }; + typedef ScheduledItem QueueItem; private: ~CurrentThreadQueue(); -- GitLab From 2d8e3541c73b89f74b552422bd477fb330227621 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Dec 2013 12:19:27 -0800 Subject: [PATCH 118/782] Add VirtualTimeScheduler --- Rx/CPP/src/cpprx/rx-base.hpp | 79 ++++++++++++++++++------------- Rx/CPP/src/cpprx/rx-scheduler.hpp | 78 ++++++++++++++++++++++++++++++ 2 files changed, 123 insertions(+), 34 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 945e8de..263dc91 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -318,18 +318,37 @@ namespace rxcpp } }; + template + class ScheduledItem { + public: + ScheduledItem(Absolute due, std::shared_ptr work) + : due(due) + , work(std::move(work)) + {} + + static Disposable Do(Scheduler::Work& work, Scheduler::shared scheduler) throw() + { + if (work) + { + return work(std::move(scheduler)); + } + return Disposable::Empty(); + } + + Absolute due; + std::shared_ptr work; + }; + struct LocalScheduler : public Scheduler { private: LocalScheduler(const LocalScheduler&); public: - static void Do(Work& work, Scheduler::shared scheduler) throw() + typedef ScheduledItem QueueItem; + static Disposable Do(Work& work, const Scheduler::shared& scheduler) throw() { - if (work) - { - work(std::move(scheduler)); - } + return QueueItem::Do(work, scheduler); } public: @@ -356,16 +375,6 @@ namespace rxcpp } }; - template - struct ScheduledItem { - ScheduledItem(Absolute due, std::shared_ptr work) - : due(due) - , work(std::move(work)) - {} - Absolute due; - std::shared_ptr work; - }; - template struct VirtualTimeSchedulerBase : public Scheduler { @@ -375,15 +384,11 @@ namespace rxcpp bool is_enabled; public: - static void Do(Work& work, Scheduler::shared scheduler) throw() + virtual ~VirtualTimeSchedulerBase() { - if (work) - { - work(std::move(scheduler)); - } } - public: + protected: VirtualTimeSchedulerBase() : is_enabled(false) { @@ -393,11 +398,11 @@ namespace rxcpp , clock_now(initialClock) { } - virtual ~VirtualTimeSchedulerBase() - { - } - protected: + typedef Scheduler::clock clock; + typedef Scheduler::Work Work; + typedef ScheduledItem QueueItem; + Absolute clock_now; virtual Absolute Add(Absolute, Relative) =0; @@ -405,9 +410,14 @@ namespace rxcpp virtual clock::time_point ToTimePoint(Absolute) =0; virtual Relative ToRelative(clock::duration) =0; - virtual ScheduledItem GetNext() =0; + virtual QueueItem GetNext() =0; public: + static Disposable Do(Work& work, const Scheduler::shared& scheduler) throw() + { + return QueueItem::Do(work, scheduler); + } + virtual Disposable ScheduleAbsolute(Absolute, Work) =0; virtual Disposable ScheduleRelative(Relative dueTime, Work work) { @@ -442,11 +452,11 @@ namespace rxcpp is_enabled = true; do { auto next = GetNext(); - if (!!next.work) { - if (next.due > clock_now) { - clock_now = next.due; + if (!!next && !!next->work && !!*next->work) { + if (next->due > clock_now) { + clock_now = next->due; } - Do(next.work, this); + Do(*next->work, shared_from_this()); } else { is_enabled = false; @@ -474,11 +484,11 @@ namespace rxcpp is_enabled = true; do { auto next = GetNext(); - if (!!next.work && next.due <= time) { - if (next.due > clock_now) { - clock_now = next.due; + if (!!next && !!next->work && !!*next->work && next->due <= time) { + if (next->due > clock_now) { + clock_now = next->due; } - Do(next.work, this); + Do(*next->work, shared_from_this()); } else { is_enabled = false; @@ -525,6 +535,7 @@ namespace rxcpp }; + template struct Notification { typedef std::function OnNext; diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 293eb5c..81e6d06 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -574,6 +574,84 @@ namespace rxcpp return scheduler->Schedule(dueTime, work); } }; + + template + class VirtualTimeScheduler : public VirtualTimeSchedulerBase + { + private: + VirtualTimeScheduler(const VirtualTimeScheduler&); + + typedef VirtualTimeSchedulerBase Base; + + typedef typename Base::clock clock; + typedef typename Base::Work Work; + typedef typename Base::QueueItem QueueItem; + + struct compare_work + { + bool operator()(const QueueItem& work1, const QueueItem& work2) const { + return work1.due > work2.due; + } + }; + + typedef std::priority_queue< + QueueItem, + std::vector, + compare_work + > ScheduledWork; + + ScheduledWork queue; + + public: + + virtual ~VirtualTimeScheduler() + { + } + + protected: + VirtualTimeScheduler() + { + } + explicit VirtualTimeScheduler(Absolute initialClock) + : Base(initialClock) + { + } + + virtual util::maybe GetNext() { + util::maybe next; + while (!queue.empty()) { + next.set(queue.top()); + if (!next->work || !*next->work) { + queue.pop(); + } + else { + return next; + } + } + return next; + } + + Disposable ScheduleAbsolute(Absolute dueTime, Work work) + { + auto cancelable = std::make_shared(std::move(work)); + + auto run = [cancelable](Scheduler::shared scheduler) -> Disposable { + auto work = *cancelable.get(); + *cancelable.get() = nullptr; + return Do(work, std::move(scheduler)); + }; + + auto si = QueueItem(dueTime, std::make_shared(std::move(run))); + queue.push(si); + + auto result = Disposable([cancelable]{ + *cancelable.get() = nullptr; + }); + return result; + } + + }; + } #endif -- GitLab From e93240d4f1cb01c77ddfc66de919971e8b9bc23b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Dec 2013 03:42:09 -0800 Subject: [PATCH 119/782] Add TestScheduler --- Rx/CPP/src/cpprx/rx-base.hpp | 83 ++++++++- Rx/CPP/src/cpprx/rx-scheduler.hpp | 297 +++++++++++++++++++++++++++++- 2 files changed, 370 insertions(+), 10 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 263dc91..530935a 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -410,7 +410,7 @@ namespace rxcpp virtual clock::time_point ToTimePoint(Absolute) =0; virtual Relative ToRelative(clock::duration) =0; - virtual QueueItem GetNext() =0; + virtual util::maybe GetNext() =0; public: static Disposable Do(Work& work, const Scheduler::shared& scheduler) throw() @@ -425,7 +425,7 @@ namespace rxcpp return ScheduleAbsolute(at, std::move(work)); } - virtual clock::time_point Now() {return ToAbsolute(clock_now);} + virtual clock::time_point Now() {return ToTimePoint(clock_now);} bool IsEnabled() {return is_enabled;} Absolute Clock() {return clock_now;} @@ -535,15 +535,51 @@ namespace rxcpp }; + template + class Recorded + { + long time; + T value; + public: + Recorded(long time, T value) : time(time), value(value) { + } + long Time() {return time;} + T Value() {return value;} + }; + + template + bool operator == (Recorded lhs, Recorded rhs) { + return lhs.Time() == rhs.Time() && lhs.Value() == rhs.Value(); + } + + class Subscription + { + long subscribe; + long unsubscribe; + + public: + explicit Subscription(long subscribe) : subscribe(subscribe), unsubscribe(std::numeric_limits::max()) { + } + Subscription(long subscribe, long unsubscribe) : subscribe(subscribe), unsubscribe(unsubscribe) { + } + long Subscribe() {return subscribe;} + long Unsubscribe() {return unsubscribe;} + }; + + bool operator == (Subscription lhs, Subscription rhs) { + return lhs.Subscribe() == rhs.Subscribe() && lhs.Unsubscribe() == rhs.Unsubscribe(); + } template - struct Notification { + struct Notification + { typedef std::function OnNext; typedef std::function OnCompleted; typedef std::function OnError; virtual ~Notification() {} + virtual bool Equals(std::shared_ptr> other) = 0; virtual void Accept(std::shared_ptr>) =0; virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) =0; @@ -551,6 +587,11 @@ namespace rxcpp struct OnNextNotification : public Notification { OnNextNotification(T value) : value(std::move(value)) { } + virtual bool Equals(std::shared_ptr> other) { + bool result = false; + other->Accept([this, &result](T value) { result = this->value == value;}, [](){}, [](std::exception_ptr){}); + return result; + } virtual void Accept(std::shared_ptr> o) { if (!o) { abort(); @@ -569,6 +610,11 @@ namespace rxcpp struct OnCompletedNotification : public Notification { OnCompletedNotification() { } + virtual bool Equals(std::shared_ptr> other) { + bool result = false; + other->Accept([](T) {}, [&result](){result = true;}, [](std::exception_ptr){}); + return result; + } virtual void Accept(std::shared_ptr> o) { if (!o) { abort(); @@ -586,6 +632,12 @@ namespace rxcpp struct OnErrorNotification : public Notification { OnErrorNotification(std::exception_ptr ep) : ep(ep) { } + virtual bool Equals(std::shared_ptr> other) { + bool result = false; + // not trying to compare exceptions + other->Accept([](T) {}, [](){}, [&result](std::exception_ptr){result = true;}); + return result; + } virtual void Accept(std::shared_ptr> o) { if (!o) { abort(); @@ -618,6 +670,31 @@ namespace rxcpp catch (...) {ep = std::current_exception();} return std::make_shared(ep); } + static + std::shared_ptr CreateOnError(std::exception_ptr ep) { + return std::make_shared(ep); + } + }; + + template + bool operator == (std::shared_ptr> lhs, std::shared_ptr> rhs) { + if (!lhs && !rhs) {return true;} + if (!lhs || !rhs) {return false;} + return lhs->Equals(rhs); + } + + template + struct TestableObserver : public Observer + { + virtual std::vector>>> Messages() =0; + }; + + template + struct TestableObservable : public Observable + { + virtual std::vector Subscriptions() =0; + + virtual std::vector>>> Messages() =0; }; template diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 81e6d06..108556b 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -583,8 +583,6 @@ namespace rxcpp typedef VirtualTimeSchedulerBase Base; - typedef typename Base::clock clock; - typedef typename Base::Work Work; typedef typename Base::QueueItem QueueItem; struct compare_work @@ -603,6 +601,8 @@ namespace rxcpp ScheduledWork queue; public: + typedef typename Base::clock clock; + typedef typename Base::Work Work; virtual ~VirtualTimeScheduler() { @@ -633,15 +633,17 @@ namespace rxcpp Disposable ScheduleAbsolute(Absolute dueTime, Work work) { - auto cancelable = std::make_shared(std::move(work)); + auto cancelable = std::make_shared(); - auto run = [cancelable](Scheduler::shared scheduler) -> Disposable { - auto work = *cancelable.get(); + auto run = [cancelable, work](Scheduler::shared scheduler) -> Disposable { + auto local = work; *cancelable.get() = nullptr; - return Do(work, std::move(scheduler)); + return Base::Do(local, std::move(scheduler)); }; + + *cancelable.get() = run; - auto si = QueueItem(dueTime, std::make_shared(std::move(run))); + auto si = QueueItem(dueTime, cancelable); queue.push(si); auto result = Disposable([cancelable]{ @@ -652,6 +654,287 @@ namespace rxcpp }; + class TestScheduler : public VirtualTimeScheduler + { + public: + typedef VirtualTimeScheduler Base; + typedef typename Base::clock clock; + typedef typename Base::Work Work; + typedef std::shared_ptr shared; + + static const long Created = 100; + static const long Subscribed = 200; + static const long Disposed = 1000; + + template + struct Messages + { + typedef Recorded>> RecordedT; + + static + RecordedT OnNext(long ticks, T value) + { + return RecordedT(ticks, Notification::CreateOnNext(value)); + } + + static + RecordedT OnCompleted(long ticks) + { + return RecordedT(ticks, Notification::CreateOnCompleted()); + } + + static + RecordedT OnError(long ticks, std::exception_ptr ep) + { + return RecordedT(ticks, Notification::CreateOnError(ep)); + } + + template + static + RecordedT OnError(long ticks, Exception e) + { + return RecordedT(ticks, Notification::CreateOnError(e)); + } + + static + Subscription Subscribe(long subscribe, long unsubscribe) + { + return Subscription(subscribe, unsubscribe); + } + + private: + ~Messages(); + }; + + virtual Disposable ScheduleAbsolute(long dueTime, Work work) + { + if (dueTime <= Base::clock_now) + dueTime = Base::clock_now + 1; + + return Base::ScheduleAbsolute(dueTime, std::move(work)); + } + + virtual long Add(long absolute, long relative) + { + return absolute + relative; + } + + virtual clock::time_point ToTimePoint(long absolute) + { + return clock::time_point(clock::duration(absolute)); + } + + virtual long ToRelative(clock::duration d) + { + return d.count(); + } + + using Base::Start; + + template + std::shared_ptr> Start(std::function>()> create, long created, long subscribed, long disposed) + { + auto observer = CreateObserver(); + + struct State + { + std::shared_ptr> source; + SerialDisposable subscription; + std::shared_ptr> observer; + }; + auto state = std::make_shared(); + + state->observer = observer; + + ScheduleAbsolute(created, [create, state](Scheduler::shared scheduler) -> Disposable { + state->source = create(); return Disposable::Empty(); }); + ScheduleAbsolute(subscribed, [state](Scheduler::shared scheduler) -> Disposable { + state->subscription.Set(state->source->Subscribe(state->observer)); return Disposable::Empty(); }); + ScheduleAbsolute(disposed, [state](Scheduler::shared scheduler) -> Disposable { + state->subscription.Dispose(); return Disposable::Empty(); }); + + Start(); + + return observer; + } + + template + std::shared_ptr> Start(std::function>()> create, long disposed) + { + return Start(create, Created, Subscribed, disposed); + } + + template + std::shared_ptr> Start(std::function>()> create) + { + return Start(create, Created, Subscribed, Disposed); + } + + template + std::shared_ptr> CreateHotObservable(std::vector>>> messages); + + template + std::shared_ptr> CreateColdObservable(std::vector>>> messages); + + template + std::shared_ptr> CreateObserver(); + }; + + template + class MockObserver : public TestableObserver + { + typedef Notification NotificationT; + typedef Recorded>> RecordedT; + + TestScheduler::shared scheduler; + std::vector messages; + + public: + MockObserver(TestScheduler::shared scheduler) + : scheduler(scheduler) + { + } + + virtual void OnNext(const T& value) + { + messages.push_back(RecordedT(scheduler->Clock(), NotificationT::CreateOnNext(value))); + } + + virtual void OnError(const std::exception_ptr& exception) + { + messages.push_back(RecordedT(scheduler->Clock(), NotificationT::CreateOnError(exception))); + } + + virtual void OnCompleted() + { + messages.push_back(RecordedT(scheduler->Clock(), NotificationT::CreateOnCompleted())); + } + + std::vector Messages() + { + return messages; + } + }; + + template + std::shared_ptr> TestScheduler::CreateObserver() + { + return std::make_shared>(std::static_pointer_cast(shared_from_this())); + } + + template + class ColdObservable : public TestableObservable, public std::enable_shared_from_this> + { + TestScheduler::shared scheduler; + typedef Recorded>> RecordedT; + std::vector messages; + std::vector subscriptions; + + public: + + ColdObservable(TestScheduler::shared scheduler, std::vector messages) + : scheduler(scheduler) + , messages(std::move(messages)) + { + } + + template + ColdObservable(TestScheduler::shared scheduler, Iterator begin, Iterator end) + : scheduler(scheduler) + , messages(begin, end) + { + } + + virtual Disposable Subscribe(std::shared_ptr> observer) + { + subscriptions.push_back(Subscription(scheduler->Clock())); + auto index = subscriptions.size() - 1; + + ComposableDisposable d; + + for (auto& message : messages) { + auto notification = message.Value(); + d.Add(scheduler->ScheduleRelative(message.Time(), [notification, observer](Scheduler::shared) -> Disposable { + notification->Accept(observer); return Disposable::Empty(); + })); + } + + auto sharedThis = this->shared_from_this(); + return Disposable([sharedThis, index, d]() { + sharedThis->subscriptions[index] = Subscription(sharedThis->subscriptions[index].Subscribe(), sharedThis->scheduler->Clock()); + d.Dispose(); + }); + } + + virtual std::vector Subscriptions() { + return subscriptions; + } + + virtual std::vector>>> Messages() { + return messages; + } + }; + + template + std::shared_ptr> TestScheduler::CreateColdObservable(std::vector>>> messages) + { + return std::make_shared>(std::static_pointer_cast(shared_from_this()), std::move(messages)); + } + + template + class HotObservable : public TestableObservable, public std::enable_shared_from_this> + { + TestScheduler::shared scheduler; + typedef Recorded>> RecordedT; + std::vector messages; + std::vector subscriptions; + std::vector>> observers; + + public: + + HotObservable(TestScheduler::shared scheduler, std::vector messages) + : scheduler(scheduler) + , messages(messages) + { + for (auto& message : messages) { + auto notification = message.Value(); + scheduler->ScheduleAbsolute(message.Time(), [this, notification](Scheduler::shared) -> Disposable { + for (auto& observer : this->observers) { + notification->Accept(observer); + } + return Disposable::Empty(); + }); + } + } + + virtual Disposable Subscribe(std::shared_ptr> observer) + { + observers.push_back(observer); + subscriptions.push_back(Subscription(scheduler->Clock())); + auto index = subscriptions.size() - 1; + + auto sharedThis = this->shared_from_this(); + return Disposable([sharedThis, index, observer]() { + sharedThis->observers.erase(std::find(sharedThis->observers.begin(), sharedThis->observers.end(), observer)); + sharedThis->subscriptions[index] = Subscription(sharedThis->subscriptions[index].Subscribe(), sharedThis->scheduler->Clock()); + }); + } + + virtual std::vector Subscriptions() { + return subscriptions; + } + + virtual std::vector>>> Messages() { + return messages; + } + }; + + template + std::shared_ptr> TestScheduler::CreateHotObservable(std::vector>>> messages) + { + return std::make_shared>(std::static_pointer_cast(shared_from_this()), std::move(messages)); + } + } #endif -- GitLab From e1190a782bc0ce57a7c6686dd29d1e873297edea Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Dec 2013 10:14:42 -0800 Subject: [PATCH 120/782] Bug fixes and pretty-printing --- .gitignore | 109 ++++++++++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-base.hpp | 36 ++++++++-- Rx/CPP/src/cpprx/rx-includes.hpp | 3 + Rx/CPP/src/cpprx/rx-scheduler.hpp | 6 ++ 4 files changed, 150 insertions(+), 4 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dd3a2a5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,109 @@ +################# +## Visual Studio +################# + +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.sln.docstates + +# Build results +[Dd]ebug/ +[Rr]elease/ +*_i.c +*_p.c +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.vspscc +.builds +*.dotCover + +## TODO: If you have NuGet Package Restore enabled, uncomment this +#packages/ + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf + +# Visual Studio profiler +*.psess +*.vsp + +# ReSharper is a .NET coding add-in +_ReSharper* + +# Installshield output folder +[Ee]xpress + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish + +# Others +[Bb]in +[Oo]bj +sql +TestResults +*.Cache +ClientBin +stylecop.* +~$* +*.dbmdl +Generated_Code #added for RIA/Silverlight projects + +# Backup & report files from converting an old project file to a newer +# Visual Studio version. Backup files are not needed, because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML + + + +############ +## Windows +############ + +# Windows image file caches +Thumbs.db + +# Folder config file +Desktop.ini + +############ +## Mac +############ + +.DS_Store + +############ +## CMake +############ + +projects/CMake/* +!projects/CMake/CMakelists.txt diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 530935a..f8e6386 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -391,6 +391,7 @@ namespace rxcpp protected: VirtualTimeSchedulerBase() : is_enabled(false) + , clock_now(0) { } explicit VirtualTimeSchedulerBase(Absolute initialClock) @@ -543,8 +544,8 @@ namespace rxcpp public: Recorded(long time, T value) : time(time), value(value) { } - long Time() {return time;} - T Value() {return value;} + long Time() const {return time;} + const T& Value() const {return value;} }; template @@ -552,6 +553,12 @@ namespace rxcpp return lhs.Time() == rhs.Time() && lhs.Value() == rhs.Value(); } + template + std::ostream& operator<< (std::ostream& out, const Recorded& r) { + out << "@" << r.Time() << "-" << r.Value(); + return out; + } + class Subscription { long subscribe; @@ -562,14 +569,19 @@ namespace rxcpp } Subscription(long subscribe, long unsubscribe) : subscribe(subscribe), unsubscribe(unsubscribe) { } - long Subscribe() {return subscribe;} - long Unsubscribe() {return unsubscribe;} + long Subscribe() const {return subscribe;} + long Unsubscribe() const {return unsubscribe;} }; bool operator == (Subscription lhs, Subscription rhs) { return lhs.Subscribe() == rhs.Subscribe() && lhs.Unsubscribe() == rhs.Unsubscribe(); } + std::ostream& operator<< (std::ostream& out, const Subscription& s) { + out << s.Subscribe() << "-" << s.Unsubscribe(); + return out; + } + template struct Notification { @@ -579,6 +591,7 @@ namespace rxcpp virtual ~Notification() {} + virtual void Out(std::ostream& out) =0; virtual bool Equals(std::shared_ptr> other) = 0; virtual void Accept(std::shared_ptr>) =0; virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) =0; @@ -587,6 +600,9 @@ namespace rxcpp struct OnNextNotification : public Notification { OnNextNotification(T value) : value(std::move(value)) { } + virtual void Out(std::ostream& out) { + out << "OnNext( " << value << ")"; + } virtual bool Equals(std::shared_ptr> other) { bool result = false; other->Accept([this, &result](T value) { result = this->value == value;}, [](){}, [](std::exception_ptr){}); @@ -610,6 +626,9 @@ namespace rxcpp struct OnCompletedNotification : public Notification { OnCompletedNotification() { } + virtual void Out(std::ostream& out) { + out << "OnCompleted()"; + } virtual bool Equals(std::shared_ptr> other) { bool result = false; other->Accept([](T) {}, [&result](){result = true;}, [](std::exception_ptr){}); @@ -632,6 +651,9 @@ namespace rxcpp struct OnErrorNotification : public Notification { OnErrorNotification(std::exception_ptr ep) : ep(ep) { } + virtual void Out(std::ostream& out) { + out << "OnError()"; + } virtual bool Equals(std::shared_ptr> other) { bool result = false; // not trying to compare exceptions @@ -683,6 +705,12 @@ namespace rxcpp return lhs->Equals(rhs); } + template + std::ostream& operator<< (std::ostream& out, const std::shared_ptr>& n) { + n->Out(out); + return out; + } + template struct TestableObserver : public Observer { diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp index 743a86f..4ef0221 100644 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ b/Rx/CPP/src/cpprx/rx-includes.hpp @@ -12,6 +12,9 @@ #include +#include +#include + #include #include #include diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 108556b..f4216c5 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -702,6 +702,12 @@ namespace rxcpp return Subscription(subscribe, unsubscribe); } + template + static + auto ToVector(const Item (&arr) [size]) -> std::vector { + return std::vector(std::begin(arr), std::end(arr)); + } + private: ~Messages(); }; -- GitLab From f8bb6ebffb1e3a376fa90bf6932160264bad1591 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Dec 2013 10:34:47 -0800 Subject: [PATCH 121/782] add support for TestableObservable and TestableObserver --- Rx/CPP/src/cpprx/rx-base.hpp | 12 ++++++++++++ Rx/CPP/src/cpprx/rx.hpp | 6 +++++- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index f8e6386..3aff92a 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -809,6 +809,9 @@ namespace detail { template struct observable_item>> {typedef T type;}; + template + struct observable_item>> {typedef T type;}; + template struct observable_item < std::shared_ptr < ConnectableObservable> > {typedef T type; }; @@ -839,6 +842,9 @@ namespace detail { template struct observer_item>> {typedef T type;}; + template + struct observer_item>> {typedef T type;}; + template struct subject_item; @@ -893,6 +899,9 @@ namespace detail { template std::shared_ptr> observable(const std::shared_ptr < GroupedObservable < K, T >> &o){ return std::static_pointer_cast < Observable < T >> (o); } + template + std::shared_ptr> observable(const std::shared_ptr < TestableObservable < T >> &o){ return std::static_pointer_cast < Observable < T >> (o); } + template std::shared_ptr< Observable < T >> observable(const std::shared_ptr < ConnectableObservable < T >> &o){ return std::static_pointer_cast < Observable < T >> (o); } @@ -931,6 +940,9 @@ namespace detail { template std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} + template + std::shared_ptr> observer(const std::shared_ptr>& o){return std::static_pointer_cast>(o);} + template std::shared_ptr> grouped_observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} } diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index ade931f..b1a32cd 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -411,7 +411,7 @@ namespace detail { auto observe_on_dispatcher() -> decltype(from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current())))) { - return from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()))); + return from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()))); } #else auto on_dispatcher() @@ -564,6 +564,10 @@ namespace detail { Binder>> from(std::shared_ptr> obj) { return Binder>>(std::move(obj)); } + template + Binder>> from(std::shared_ptr> obj) { + return Binder>>(std::move(obj)); } + template Binder from(Binder binder) { return std::move(binder); } -- GitLab From 5eeb82060c447e2b23454214cf84ba0ea02c8ed2 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Mon, 2 Dec 2013 12:26:51 -0800 Subject: [PATCH 122/782] improve windows build --- Rx/CPP/src/cpprx/rx-scheduler.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index f4216c5..bc3dc60 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -658,8 +658,8 @@ namespace rxcpp { public: typedef VirtualTimeScheduler Base; - typedef typename Base::clock clock; - typedef typename Base::Work Work; + typedef Base::clock clock; + typedef Base::Work Work; typedef std::shared_ptr shared; static const long Created = 100; @@ -732,7 +732,7 @@ namespace rxcpp virtual long ToRelative(clock::duration d) { - return d.count(); + return static_cast(d.count()); } using Base::Start; -- GitLab From a5afc4e3ceb74c75d6b1550759b9090661e5f732 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Dec 2013 19:25:30 -0800 Subject: [PATCH 123/782] fix duplicate symbol errors in clang --- Rx/CPP/src/cpprx/rx-base.hpp | 12 ++++----- Rx/CPP/src/cpprx/rx-scheduler.hpp | 41 ++++++++++++++++--------------- 2 files changed, 27 insertions(+), 26 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 3aff92a..91c2522 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -565,19 +565,19 @@ namespace rxcpp long unsubscribe; public: - explicit Subscription(long subscribe) : subscribe(subscribe), unsubscribe(std::numeric_limits::max()) { + explicit inline Subscription(long subscribe) : subscribe(subscribe), unsubscribe(std::numeric_limits::max()) { } - Subscription(long subscribe, long unsubscribe) : subscribe(subscribe), unsubscribe(unsubscribe) { + inline Subscription(long subscribe, long unsubscribe) : subscribe(subscribe), unsubscribe(unsubscribe) { } - long Subscribe() const {return subscribe;} - long Unsubscribe() const {return unsubscribe;} + inline long Subscribe() const {return subscribe;} + inline long Unsubscribe() const {return unsubscribe;} }; - bool operator == (Subscription lhs, Subscription rhs) { + inline bool operator == (Subscription lhs, Subscription rhs) { return lhs.Subscribe() == rhs.Subscribe() && lhs.Unsubscribe() == rhs.Unsubscribe(); } - std::ostream& operator<< (std::ostream& out, const Subscription& s) { + inline std::ostream& operator<< (std::ostream& out, const Subscription& s) { out << s.Subscribe() << "-" << s.Unsubscribe(); return out; } diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index bc3dc60..385cb39 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -42,44 +42,47 @@ namespace rxcpp }; private: - RXCPP_THREAD_LOCAL static ThreadLocalQueue* threadLocalQueue; + static ThreadLocalQueue*& threadLocalQueue() { + RXCPP_THREAD_LOCAL static ThreadLocalQueue* queue; + return queue; + } public: static Scheduler::shared GetScheduler() { - return !!threadLocalQueue ? threadLocalQueue->scheduler : Scheduler::shared(); + return !!threadLocalQueue() ? threadLocalQueue()->scheduler : Scheduler::shared(); } static bool empty() { - if (!threadLocalQueue) { + if (!threadLocalQueue()) { throw std::logic_error("this thread does not have a queue!"); } - return threadLocalQueue->queue.empty(); + return threadLocalQueue()->queue.empty(); } static ScheduledWork::const_reference top() { - if (!threadLocalQueue) { + if (!threadLocalQueue()) { throw std::logic_error("this thread does not have a queue!"); } - return threadLocalQueue->queue.top(); + return threadLocalQueue()->queue.top(); } static void pop() { - if (!threadLocalQueue) { + if (!threadLocalQueue()) { throw std::logic_error("this thread does not have a queue!"); } - threadLocalQueue->queue.pop(); + threadLocalQueue()->queue.pop(); } static void push(QueueItem item) { - if (!threadLocalQueue) { + if (!threadLocalQueue()) { throw std::logic_error("this thread does not have a queue!"); } - threadLocalQueue->queue.push(std::move(item)); + threadLocalQueue()->queue.push(std::move(item)); } static void EnsureQueue(Scheduler::shared scheduler) { - if (!!threadLocalQueue) { + if (!!threadLocalQueue()) { throw std::logic_error("this thread already has a queue!"); } // create and publish new queue - threadLocalQueue = new ThreadLocalQueue(); - threadLocalQueue->scheduler = scheduler; + threadLocalQueue() = new ThreadLocalQueue(); + threadLocalQueue()->scheduler = scheduler; } static std::unique_ptr CreateQueue(Scheduler::shared scheduler) { std::unique_ptr result(new ThreadLocalQueue()); @@ -87,25 +90,23 @@ namespace rxcpp return result; } static void SetQueue(ThreadLocalQueue* queue) { - if (!!threadLocalQueue) { + if (!!threadLocalQueue()) { throw std::logic_error("this thread already has a queue!"); } // create and publish new queue - threadLocalQueue = queue; + threadLocalQueue() = queue; } static void DestroyQueue(ThreadLocalQueue* queue) { delete queue; } static void DestroyQueue() { - if (!threadLocalQueue) { + if (!threadLocalQueue()) { throw std::logic_error("this thread does not have a queue!"); } - DestroyQueue(threadLocalQueue); - threadLocalQueue = nullptr; + DestroyQueue(threadLocalQueue()); + threadLocalQueue() = nullptr; } }; - // static - RXCPP_SELECT_ANY RXCPP_THREAD_LOCAL CurrentThreadQueue::ThreadLocalQueue* CurrentThreadQueue::threadLocalQueue = nullptr; struct CurrentThreadScheduler : public LocalScheduler { -- GitLab From 9e5b2ca9f1bafb6fb982cb3bf7ed2de6def3127d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 2 Dec 2013 19:26:02 -0800 Subject: [PATCH 124/782] reimplement Where to fix dispose bug --- Rx/CPP/src/cpprx/operators/Where.hpp | 100 ++++++++++++++++++--------- 1 file changed, 67 insertions(+), 33 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Where.hpp b/Rx/CPP/src/cpprx/operators/Where.hpp index 679ffab..5119cb3 100644 --- a/Rx/CPP/src/cpprx/operators/Where.hpp +++ b/Rx/CPP/src/cpprx/operators/Where.hpp @@ -8,44 +8,78 @@ namespace rxcpp { + namespace detail + { + template + class WhereObservable : public Producer, T> + { + typedef std::shared_ptr> Parent; + typedef std::function Predicate; + + std::shared_ptr> source; + Predicate predicate; + + class _ : public Sink<_, T>, public Observer + { + Parent parent; + + public: + typedef Sink<_, T> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + virtual void OnNext(const T& t) + { + util::maybe shouldRun; + try { + shouldRun.set(parent->predicate(t)); + } catch (...) { + SinkBase::observer->OnError(std::current_exception()); + SinkBase::Dispose(); + } + if (!!shouldRun && *shouldRun.get()) { + SinkBase::observer->OnNext(t); + } + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer, T> ProducerBase; + public: + + WhereObservable(const std::shared_ptr>& source, Predicate predicate) : + ProducerBase([this](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(source), + predicate(std::move(predicate)) + { + } + }; + } template - const std::shared_ptr> Where( + std::shared_ptr> Where( const std::shared_ptr>& source, P predicate - ) + ) { - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - typedef decltype(predicate(element)) U; - util::maybe result; - try { - result.set(predicate(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result && *result.get()) - { - observer->OnNext(element); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); + return std::make_shared>(source, std::move(predicate)); } } -- GitLab From 3e3bf958c6122fce0130e8ca5878d0169c2e5f7d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Dec 2013 00:26:31 -0800 Subject: [PATCH 125/782] ignore projects --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index dd3a2a5..ca7abf5 100644 --- a/.gitignore +++ b/.gitignore @@ -105,5 +105,5 @@ Desktop.ini ## CMake ############ -projects/CMake/* +projects/* !projects/CMake/CMakelists.txt -- GitLab From 47f02bc502e3cba918906853a12d7367c0d911fa Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Dec 2013 00:27:23 -0800 Subject: [PATCH 126/782] remove bad code --- Rx/CPP/src/cpprx/rx-operators.hpp | 87 ++++++------------------------- 1 file changed, 17 insertions(+), 70 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index fabb763..2c4525b 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -13,18 +13,24 @@ namespace rxcpp // // constructors template - struct CreatedAutoDetachObserver : public Observer + struct CreatedAutoDetachObserver : public Observer, public std::enable_shared_from_this> { std::shared_ptr> observer; + std::atomic isStopped; SerialDisposable disposable; virtual ~CreatedAutoDetachObserver() { - clear(); + } + + CreatedAutoDetachObserver() + : isStopped(false) + { } virtual void OnNext(const T& element) { - if (observer) { + auto keepAlive = this->shared_from_this(); + if (!isStopped) { RXCPP_UNWIND(disposer, [&](){ disposable.Dispose(); }); @@ -34,34 +40,26 @@ namespace rxcpp } virtual void OnCompleted() { - if (observer) { + auto keepAlive = this->shared_from_this(); + if (!isStopped.exchange(true)) { RXCPP_UNWIND(disposer, [&](){ disposable.Dispose(); }); - std::shared_ptr> final; - using std::swap; - swap(final, observer); - final->OnCompleted(); + observer->OnCompleted(); disposer.dismiss(); } } virtual void OnError(const std::exception_ptr& error) { - if (observer) { + auto keepAlive = this->shared_from_this(); + if (!isStopped.exchange(true)) { RXCPP_UNWIND(disposer, [&](){ disposable.Dispose(); }); - std::shared_ptr> final; - using std::swap; - swap(final, observer); - final->OnError(error); + observer->OnError(error); disposer.dismiss(); } } - void clear() - { - observer = nullptr; - } }; template @@ -127,7 +125,6 @@ namespace rxcpp std::function onError; virtual ~CreatedObserver() { - clear(); } virtual void OnNext(const T& element) @@ -141,30 +138,16 @@ namespace rxcpp { if(onCompleted) { - std::function final; - using std::swap; - swap(final, onCompleted); - clear(); - final(); + onCompleted(); } } virtual void OnError(const std::exception_ptr& error) { if(onError) { - std::function final; - using std::swap; - swap(final, onError); - clear(); - final(error); + onError(error); } } - void clear() - { - onNext = nullptr; - onCompleted = nullptr; - onError = nullptr; - } }; template @@ -189,7 +172,6 @@ namespace rxcpp class Sink : public std::enable_shared_from_this { typedef std::shared_ptr> SinkObserver; - mutable std::mutex lock; mutable util::maybe cancel; protected: @@ -208,7 +190,6 @@ namespace rxcpp void Dispose() const { - std::unique_lock guard(lock); observer = std::make_shared>(); if (cancel) { @@ -227,40 +208,6 @@ namespace rxcpp local->Dispose(); }); } - - class _ : public Observer - { - std::shared_ptr that; - public: - _(std::shared_ptr that) : that(that) - {} - - virtual void OnNext(const T& t) - { - std::unique_lock guard(that->lock); - that->observer->OnNext(t); - } - virtual void OnCompleted() - { - std::unique_lock guard(that->lock); - that->observer->OnCompleted(); - if (that->cancel) - { - that->cancel->Dispose(); - that->cancel.reset(); - } - } - virtual void OnError(const std::exception_ptr& e) - { - std::unique_lock guard(that->lock); - that->observer->OnError(e); - if (that->cancel) - { - that->cancel->Dispose(); - that->cancel.reset(); - } - } - }; }; template -- GitLab From 557b829cab4dc8c4f0550e9012d72c19e06985d4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Dec 2013 00:27:42 -0800 Subject: [PATCH 127/782] fix Zip --- Rx/CPP/src/cpprx/operators/Zip.hpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Rx/CPP/src/cpprx/operators/Zip.hpp b/Rx/CPP/src/cpprx/operators/Zip.hpp index 3d51f0c..13a7b0f 100644 --- a/Rx/CPP/src/cpprx/operators/Zip.hpp +++ b/Rx/CPP/src/cpprx/operators/Zip.hpp @@ -108,6 +108,7 @@ namespace rxcpp [=](const Item& element) { std::unique_lock guard(state->lock); + if (state->isStopped) {return;} std::get(state->queues).second.push(element); Next next(state, observer, cd); util::tuple_dispatch(next, state->queues); @@ -116,6 +117,7 @@ namespace rxcpp [=] { std::unique_lock guard(state->lock); + if (state->isStopped) {return;} std::get(state->queues).first = true; Next next(state, observer, cd); util::tuple_dispatch(next, state->queues); @@ -124,6 +126,7 @@ namespace rxcpp [=](const std::exception_ptr& error) { std::unique_lock guard(state->lock); + if (state->isStopped) {return;} observer->OnError(error); cd.Dispose(); })); @@ -158,10 +161,12 @@ namespace rxcpp typedef std::tuple_size SourcesSize; explicit State(S selector) : selector(std::move(selector)) + , isStopped(false) {} std::mutex lock; S selector; Queues queues; + bool isStopped; }; Sources sources(source...); // bug on osx prevents using make_shared @@ -170,6 +175,7 @@ namespace rxcpp [=](std::shared_ptr> observer) -> Disposable { ComposableDisposable cd; + cd.Add(Disposable([state](){state->isStopped = true;})); detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); return cd; }); -- GitLab From 0949ad5fcd2caf90fbcfd02077a015bdbb131eb5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Dec 2013 00:27:59 -0800 Subject: [PATCH 128/782] reimplement Take --- Rx/CPP/src/cpprx/operators/Take.hpp | 112 +++++++++++++++++----------- 1 file changed, 69 insertions(+), 43 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Take.hpp b/Rx/CPP/src/cpprx/operators/Take.hpp index 8414394..2ffec60 100644 --- a/Rx/CPP/src/cpprx/operators/Take.hpp +++ b/Rx/CPP/src/cpprx/operators/Take.hpp @@ -9,57 +9,83 @@ namespace rxcpp { - template - std::shared_ptr> Take( - const std::shared_ptr>& source, - Integral n - ) + namespace detail { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable + template + class TakeObservable : public Producer, T> + { + typedef std::shared_ptr> Parent; + + std::shared_ptr> source; + Integral count; + + class _ : public Sink<_, T>, public Observer { - // keep count of remaining calls received OnNext and count of OnNext calls issued. - auto remaining = std::make_shared, std::atomic>>(n, n); + Parent parent; + Integral remaining; - ComposableDisposable cd; + public: + typedef Sink<_, T> SinkBase; - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - auto local = --std::get<0>(*remaining); - RXCPP_UNWIND_AUTO([&](){ - if (local >= 0){ - // all elements received - if (--std::get<1>(*remaining) == 0) { - // all elements passed on to observer. - observer->OnCompleted(); - cd.Dispose();}}}); - - if (local >= 0) { - observer->OnNext(element); - } - }, - // on completed - [=] + _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent), + remaining(parent->count) + { + } + + virtual void OnNext(const T& t) + { + if (remaining > 0) { - if (std::get<1>(*remaining) == 0 && std::get<0>(*remaining) <= 0) { - observer->OnCompleted(); - cd.Dispose(); + --remaining; + SinkBase::observer->OnNext(t); + + if (remaining == 0) + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); } - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); + } + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer, T> ProducerBase; + public: + + TakeObservable(const std::shared_ptr>& source, Integral count) : + ProducerBase([this](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(source), + count(count) + { + } + }; + } + template + std::shared_ptr> Take( + const std::shared_ptr>& source, + Integral n + ) + { + return std::make_shared>(source, n); } + template std::shared_ptr> TakeUntil( const std::shared_ptr>& source, -- GitLab From e754305d404622b252752fa46d13732ad27f38af Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Dec 2013 00:28:15 -0800 Subject: [PATCH 129/782] fix compiler warning --- Rx/CPP/src/cpprx/operators/RefCount.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/RefCount.hpp b/Rx/CPP/src/cpprx/operators/RefCount.hpp index a1997fd..22a8224 100644 --- a/Rx/CPP/src/cpprx/operators/RefCount.hpp +++ b/Rx/CPP/src/cpprx/operators/RefCount.hpp @@ -83,8 +83,8 @@ namespace rxcpp setSink(sink->GetDisposable()); return sink->Run(); }), - refcount(0), - source(std::move(source)) + source(std::move(source)), + refcount(0) { subscription.set(Disposable::Empty()); } -- GitLab From 44c3a898ee362457884c1093c956aebef145bcff Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 3 Dec 2013 00:28:31 -0800 Subject: [PATCH 130/782] fix CombineLatest --- Rx/CPP/src/cpprx/operators/CombineLatest.hpp | 59 +++++++------------- 1 file changed, 20 insertions(+), 39 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp index 0e98c3f..cf5af07 100644 --- a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp +++ b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp @@ -23,35 +23,24 @@ namespace rxcpp // on next [=](const typename std::tuple_element::type& element) { - auto local = state; - std::unique_lock guard(local->lock); - std::get(local->latest) = element; - if (!std::get(local->latestValid)) { - std::get(local->latestValid) = true; - --local->pendingFirst; + std::unique_lock guard(state->lock); + if (state->done) {return;} + std::get(state->latest) = element; + if (!std::get(state->latestValid)) { + std::get(state->latestValid) = true; + --state->pendingFirst; } - if (local->pendingFirst == 0) { - Latest args = local->latest; - typedef decltype(util::tuple_dispatch(local->selector, args)) U; + if (state->pendingFirst == 0) { + Latest args = state->latest; + typedef decltype(util::tuple_dispatch(state->selector, args)) U; util::maybe result; try { - result.set(util::tuple_dispatch(local->selector, args)); + result.set(util::tuple_dispatch(state->selector, args)); } catch(...) { observer->OnError(std::current_exception()); } if (!!result) { - ++state->pendingIssue; - { - RXCPP_UNWIND_AUTO([&](){guard.lock();}); - guard.unlock(); - observer->OnNext(std::move(*result.get())); - } - --state->pendingIssue; - } - if (state->done && state->pendingIssue == 0) { - guard.unlock(); - observer->OnCompleted(); - cd.Dispose(); + observer->OnNext(std::move(*result.get())); } } }, @@ -59,19 +48,17 @@ namespace rxcpp [=] { std::unique_lock guard(state->lock); - --state->pendingComplete; - if (state->pendingComplete == 0) { - state->done = true; - if (state->pendingIssue == 0) { - guard.unlock(); - observer->OnCompleted(); - cd.Dispose(); - } - } + if (state->done) {return;} + state->done = true; + observer->OnCompleted(); + cd.Dispose(); }, // on error [=](const std::exception_ptr& error) { + std::unique_lock guard(state->lock); + if (state->done) {return;} + state->done = true; observer->OnError(error); cd.Dispose(); })); @@ -109,16 +96,12 @@ namespace rxcpp explicit State(S selector) : latestValid() , pendingFirst(SourcesSize::value) - , pendingIssue(0) - , pendingComplete(SourcesSize::value) , done(false) , selector(std::move(selector)) {} std::mutex lock; LatestValid latestValid; size_t pendingFirst; - size_t pendingIssue; - size_t pendingComplete; bool done; S selector; Latest latest; @@ -130,6 +113,7 @@ namespace rxcpp [=](std::shared_ptr> observer) -> Disposable { ComposableDisposable cd; + cd.Add(Disposable([state](){state->done = true;})); detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); return cd; }); @@ -155,16 +139,12 @@ namespace rxcpp explicit State(S selector) : latestValid() , pendingFirst(SourcesSize::value) - , pendingIssue(0) - , pendingComplete(SourcesSize::value) , done(false) , selector(std::move(selector)) {} std::mutex lock; LatestValid latestValid; size_t pendingFirst; - size_t pendingIssue; - size_t pendingComplete; bool done; S selector; Latest latest; @@ -176,6 +156,7 @@ namespace rxcpp [=](std::shared_ptr> observer) -> Disposable { ComposableDisposable cd; + cd.Add(Disposable([state](){state->done = true;})); detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); return cd; }); -- GitLab From 75bf4eb291863f2668e8bebe8b16a605657d2206 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 4 Dec 2013 23:33:14 -0800 Subject: [PATCH 131/782] record more data in testbench --- Rx/CPP/testbench/testbench.cpp | 124 ++++++++++++++++++--------------- 1 file changed, 68 insertions(+), 56 deletions(-) diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp index 2e41f4d..4fd5e8c 100644 --- a/Rx/CPP/testbench/testbench.cpp +++ b/Rx/CPP/testbench/testbench.cpp @@ -18,6 +18,56 @@ using namespace std; bool IsPrime(int x); +struct Count { + Count() : subscriptions(0), nexts(0), completions(0), errors(0), disposals(0) {} + std::atomic subscriptions; + std::atomic nexts; + std::atomic completions; + std::atomic errors; + std::atomic disposals; +}; +template +std::shared_ptr> Record( + const std::shared_ptr>& source, + Count* count +) +{ + return rxcpp::CreateObservable( + [=](std::shared_ptr> observer) -> rxcpp::Disposable + { + ++count->subscriptions; + rxcpp::ComposableDisposable cd; + cd.Add(rxcpp::Disposable([=](){ + ++count->disposals;})); + cd.Add(rxcpp::Subscribe( + source, + // on next + [=](T element) + { + ++count->nexts; + observer->OnNext(std::move(element)); + }, + // on completed + [=] + { + ++count->completions; + observer->OnCompleted(); + }, + // on error + [=](const std::exception_ptr& error) + { + ++count->errors; + observer->OnError(error); + })); + return cd; + }); +} +struct record {}; +template +rxcpp::Binder>> rxcpp_chain(record&&, const std::shared_ptr>& source, Count* count) { + return rxcpp::from(Record(source, count)); +} + vector vector_range(int start, int end) { vector v; @@ -27,6 +77,8 @@ vector vector_range(int start, int end) } void IxToRx(int n) { + Count sourcecount, takencount, observedcount; + std::cout << "IxToRx: first " << n << " primes squared" << endl; auto values = vector_range(2, n * 10); @@ -34,15 +86,22 @@ void IxToRx(int n) { .where(IsPrime) .select([](int x) { return std::make_pair(x, x*x); }); - auto input = std::make_shared(); auto output = std::make_shared(); - rxcpp::from(Iterate(primes, input)) + rxcpp::from(rxcpp::Iterate(primes)) + .template chain(&sourcecount) .take(n) + .template chain(&takencount) .observe_on(output) + .template chain(&observedcount) .for_each(rxcpp::MakeTupleDispatch( [](int p, int s) { cout << p << " =square=> " << s << endl; })); + + cout << "location: subscriptions, nexts, completions, errors, disposals" << endl; + cout << "sourcecount: " << sourcecount.subscriptions << ", " << sourcecount.nexts << ", " << sourcecount.completions << ", " << sourcecount.errors << ", " << sourcecount.disposals << endl; + cout << "takencount: " << takencount.subscriptions << ", " << takencount.nexts << ", " << takencount.completions << ", " << takencount.errors << ", " << takencount.disposals << endl; + cout << "observedcount: " << observedcount.subscriptions << ", " << observedcount.nexts << ", " << observedcount.completions << ", " << observedcount.errors << ", " << observedcount.disposals << endl; } void PrintPrimes(int n) @@ -170,53 +229,7 @@ void Combine(int n) })); } -struct Count { - Count() : nexts(0), completions(0), errors(0), disposals(0) {} - std::atomic nexts; - std::atomic completions; - std::atomic errors; - std::atomic disposals; -}; -template -std::shared_ptr> Record( - const std::shared_ptr>& source, - Count* count - ) -{ - return rxcpp::CreateObservable( - [=](std::shared_ptr> observer) -> rxcpp::Disposable - { - rxcpp::ComposableDisposable cd; - cd.Add(rxcpp::Disposable([=](){ - ++count->disposals;})); - cd.Add(rxcpp::Subscribe( - source, - // on next - [=](T element) - { - ++count->nexts; - observer->OnNext(std::move(element)); - }, - // on completed - [=] - { - ++count->completions; - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - ++count->errors; - observer->OnError(error); - })); - return cd; - }); -} -struct record {}; -template -rxcpp::Binder>> rxcpp_chain(record&&, const std::shared_ptr>& source, Count* count) { - return rxcpp::from(Record(source, count)); -} + template void Zip(int n) @@ -251,12 +264,12 @@ void Zip(int n) cout << p2 << " =zipped=> " << p1 << endl; })); - cout << "location: nexts, completions, errors, disposals" << endl; - cout << "s1count:" << s1count.nexts << ", " << s1count.completions << ", " << s1count.errors << ", " << s1count.disposals << endl; - cout << "s2count:" << s2count.nexts << ", " << s2count.completions << ", " << s2count.errors << ", " << s2count.disposals << endl; - cout << "zipcount:" << zipcount.nexts << ", " << zipcount.completions << ", " << zipcount.errors << ", " << zipcount.disposals << endl; - cout << "takecount:" << takecount.nexts << ", " << takecount.completions << ", " << takecount.errors << ", " << takecount.disposals << endl; - cout << "outputcount:" << outputcount.nexts << ", " << outputcount.completions << ", " << outputcount.errors << ", " << outputcount.disposals << endl; + cout << "location: subscriptions, nexts, completions, errors, disposals" << endl; + cout << "s1count: " << s1count.subscriptions << ", " << s1count.nexts << ", " << s1count.completions << ", " << s1count.errors << ", " << s1count.disposals << endl; + cout << "s2count: " << s2count.subscriptions << ", " << s2count.nexts << ", " << s2count.completions << ", " << s2count.errors << ", " << s2count.disposals << endl; + cout << "zipcount: " << zipcount.subscriptions << ", " << zipcount.nexts << ", " << zipcount.completions << ", " << zipcount.errors << ", " << zipcount.disposals << endl; + cout << "takecount: " << takecount.subscriptions << ", " << takecount.nexts << ", " << takecount.completions << ", " << takecount.errors << ", " << takecount.disposals << endl; + cout << "outputcount: " << outputcount.subscriptions << ", " << outputcount.nexts << ", " << outputcount.completions << ", " << outputcount.errors << ", " << outputcount.disposals << endl; } void Merge(int n) @@ -551,7 +564,6 @@ int main(int argc, char* argv[]) Scan(); run(); - } catch (exception& e) { cerr << "exception: " << e.what() << endl; } -- GitLab From cd1318186f7c669df1ff73a97309da430ca98f81 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 4 Dec 2013 23:38:26 -0800 Subject: [PATCH 132/782] work around clang compiler bug --- Rx/CPP/src/cpprx/operators/Iterate.hpp | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Iterate.hpp b/Rx/CPP/src/cpprx/operators/Iterate.hpp index 1ccca10..8478de1 100644 --- a/Rx/CPP/src/cpprx/operators/Iterate.hpp +++ b/Rx/CPP/src/cpprx/operators/Iterate.hpp @@ -28,7 +28,15 @@ namespace rxcpp { struct State { - explicit State(std::shared_ptr rangeArg) : cancel(false) { + explicit State(std::shared_ptr rangeArg) { + // finally tracked down issue caused by clang compiler bug. + // initializing in the init list only works sometimes. + // a breakpoint here would eventually show that + // cancel was true instead of false. + // initializing in the body instead works every time. + // or using new instead of std::make_shared to create + // State will cause the init list to work every time + this->cancel = false; this->range = std::move(rangeArg); this->r_cursor = begin(*this->range); this->r_end = end(*this->range); @@ -45,8 +53,12 @@ namespace rxcpp cd.Add(Disposable([=]{ state->cancel = true; })); + + SerialDisposable sd; + + cd.Add(sd); - cd.Add(scheduler->Schedule( + sd.Set(scheduler->Schedule( fix0([=](Scheduler::shared s, std::function self) -> Disposable { if (state->cancel) @@ -60,7 +72,8 @@ namespace rxcpp { observer->OnNext(*state->r_cursor); ++state->r_cursor; - return s->Schedule(std::move(self)); + sd.Set(s->Schedule(std::move(self))); + return cd; } return Disposable::Empty(); }))); -- GitLab From 3d872b55551ddefce2d7635da851364da3d8fbda Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 4 Dec 2013 23:41:23 -0800 Subject: [PATCH 133/782] Make Work Disposable and fix schedulers --- Rx/CPP/src/cpprx/rx-base.hpp | 86 +++++++++- Rx/CPP/src/cpprx/rx-operators.hpp | 35 ++-- Rx/CPP/src/cpprx/rx-scheduler.hpp | 262 ++++++++++++++++++------------ 3 files changed, 258 insertions(+), 125 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 91c2522..1c10226 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -76,7 +76,79 @@ namespace rxcpp { typedef std::chrono::steady_clock clock; typedef std::shared_ptr shared; - typedef std::function Work; + + class Work { + struct bool_r{}; + static bool_r bool_true(){return bool_r();} + typedef decltype(&bool_true) bool_type; + + struct State + { + typedef std::function F; + F work; + bool disposed; + inline void Dispose() { + disposed = true; + } + }; + std::shared_ptr state; + + template + struct assign + { + void operator()(const std::shared_ptr& state, State::F fn) { + state->work = std::move(fn); + } + }; + + template + struct assign + { + void operator()(std::shared_ptr& state, const Work& o) { + state = o.state; + } + void operator()(std::shared_ptr& state, Work&& o) { + state = std::move(o.state); + } + }; + public: + Work() + : state(std::make_shared()) + { + state->disposed = false; + } + template + Work(Fn&& fn) + : state(std::make_shared()) + { + assign<1, std::is_same::type>::value>()(state, std::forward(fn)); + state->disposed = false; + } + template + Work& operator=(Fn&& fn) + { + assign<1, std::is_same::type>::value>()(state, std::forward(fn)); + return *this; + } + inline Disposable operator()(shared s) { + if (!state->disposed) { + return state->work(s); + } + return Disposable::Empty(); + } + inline operator bool_type() const {return (!state->disposed && !!state->work) ? &bool_true : nullptr;} + inline void Dispose() const { + state->Dispose(); + } + inline operator Disposable() const + { + // make sure to capture state and not 'this'. + auto local = state; + return Disposable([local]{ + local->Dispose(); + }); + } + }; shared get() {return shared_from_this();} @@ -321,7 +393,7 @@ namespace rxcpp template class ScheduledItem { public: - ScheduledItem(Absolute due, std::shared_ptr work) + ScheduledItem(Absolute due, Scheduler::Work work) : due(due) , work(std::move(work)) {} @@ -336,7 +408,7 @@ namespace rxcpp } Absolute due; - std::shared_ptr work; + Scheduler::Work work; }; struct LocalScheduler : public Scheduler @@ -453,11 +525,11 @@ namespace rxcpp is_enabled = true; do { auto next = GetNext(); - if (!!next && !!next->work && !!*next->work) { + if (!!next && !!next->work) { if (next->due > clock_now) { clock_now = next->due; } - Do(*next->work, shared_from_this()); + Do(next->work, shared_from_this()); } else { is_enabled = false; @@ -485,11 +557,11 @@ namespace rxcpp is_enabled = true; do { auto next = GetNext(); - if (!!next && !!next->work && !!*next->work && next->due <= time) { + if (!!next && !!next->work && next->due <= time) { if (next->due > clock_now) { clock_now = next->due; } - Do(*next->work, shared_from_this()); + Do(next->work, shared_from_this()); } else { is_enabled = false; diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 2c4525b..fdd81f7 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -16,10 +16,13 @@ namespace rxcpp struct CreatedAutoDetachObserver : public Observer, public std::enable_shared_from_this> { std::shared_ptr> observer; - std::atomic isStopped; - SerialDisposable disposable; + mutable std::atomic isStopped; + mutable SerialDisposable disposable; virtual ~CreatedAutoDetachObserver() { + if (!isStopped) { + abort(); + } } CreatedAutoDetachObserver() @@ -29,9 +32,10 @@ namespace rxcpp virtual void OnNext(const T& element) { - auto keepAlive = this->shared_from_this(); if (!isStopped) { + auto keepAlive = this->shared_from_this(); RXCPP_UNWIND(disposer, [&](){ + isStopped = true; disposable.Dispose(); }); observer->OnNext(element); @@ -40,26 +44,37 @@ namespace rxcpp } virtual void OnCompleted() { - auto keepAlive = this->shared_from_this(); if (!isStopped.exchange(true)) { + auto keepAlive = this->shared_from_this(); RXCPP_UNWIND(disposer, [&](){ disposable.Dispose(); }); observer->OnCompleted(); - disposer.dismiss(); } } virtual void OnError(const std::exception_ptr& error) { - auto keepAlive = this->shared_from_this(); if (!isStopped.exchange(true)) { + auto keepAlive = this->shared_from_this(); RXCPP_UNWIND(disposer, [&](){ disposable.Dispose(); }); observer->OnError(error); - disposer.dismiss(); } } + + void Dispose() const { + isStopped = true; + disposable.Dispose(); + } + operator Disposable() const + { + // make sure to capture state and not 'this'. + auto local = this->shared_from_this(); + return Disposable([local]{ + local->Dispose(); + }); + } }; template @@ -99,15 +114,15 @@ namespace rxcpp return Disposable::Empty(); } ); - return autoDetachObserver->disposable; + return *autoDetachObserver; } try { autoDetachObserver->disposable.Set(subscribe(autoDetachObserver)); - return autoDetachObserver->disposable; + return *autoDetachObserver; } catch (...) { autoDetachObserver->OnError(std::current_exception()); } - return Disposable::Empty(); + return *autoDetachObserver; } }; diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 385cb39..cac1534 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -54,31 +54,31 @@ namespace rxcpp } static bool empty() { if (!threadLocalQueue()) { - throw std::logic_error("this thread does not have a queue!"); + abort(); } return threadLocalQueue()->queue.empty(); } static ScheduledWork::const_reference top() { if (!threadLocalQueue()) { - throw std::logic_error("this thread does not have a queue!"); + abort(); } return threadLocalQueue()->queue.top(); } static void pop() { if (!threadLocalQueue()) { - throw std::logic_error("this thread does not have a queue!"); + abort(); } threadLocalQueue()->queue.pop(); } static void push(QueueItem item) { if (!threadLocalQueue()) { - throw std::logic_error("this thread does not have a queue!"); + abort(); } threadLocalQueue()->queue.push(std::move(item)); } static void EnsureQueue(Scheduler::shared scheduler) { if (!!threadLocalQueue()) { - throw std::logic_error("this thread already has a queue!"); + abort(); } // create and publish new queue threadLocalQueue() = new ThreadLocalQueue(); @@ -91,9 +91,9 @@ namespace rxcpp } static void SetQueue(ThreadLocalQueue* queue) { if (!!threadLocalQueue()) { - throw std::logic_error("this thread already has a queue!"); + abort(); } - // create and publish new queue + // publish new queue threadLocalQueue() = queue; } static void DestroyQueue(ThreadLocalQueue* queue) { @@ -101,7 +101,7 @@ namespace rxcpp } static void DestroyQueue() { if (!threadLocalQueue()) { - throw std::logic_error("this thread does not have a queue!"); + abort(); } DestroyQueue(threadLocalQueue()); threadLocalQueue() = nullptr; @@ -130,12 +130,10 @@ namespace rxcpp using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { - auto cancelable = std::make_shared(std::move(work)); - - CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, cancelable)); + CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, work)); - return Disposable([cancelable]{ - *cancelable.get() = nullptr;}); + // work is disposable + return work; } }; @@ -162,14 +160,12 @@ namespace rxcpp // take ownership - auto cancelable = std::make_shared(std::move(work)); - CurrentThreadQueue::EnsureQueue(std::make_shared()); RXCPP_UNWIND_AUTO([]{ CurrentThreadQueue::DestroyQueue(); }); - CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); + CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, std::move(work))); // loop until queue is empty for ( @@ -179,8 +175,8 @@ namespace rxcpp ) { // dispatch work - auto work = std::move(*CurrentThreadQueue::top().work.get()); - *CurrentThreadQueue::top().work.get() = nullptr; + auto work = CurrentThreadQueue::top().work; + CurrentThreadQueue::pop(); Do(work, get()); @@ -197,8 +193,15 @@ namespace rxcpp private: ImmediateScheduler(const ImmediateScheduler&); + mutable std::mutex lock; + mutable bool hasFaulted; + mutable bool isAquired; + mutable CurrentThreadQueue::ThreadLocalQueue* queue; public: ImmediateScheduler() + : hasFaulted(false) + , isAquired(false) + , queue(nullptr) { } virtual ~ImmediateScheduler() @@ -208,10 +211,61 @@ namespace rxcpp using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { - auto ct = std::make_shared(); - std::this_thread::sleep_until(dueTime); - Do(work, ct); - return Disposable::Empty(); + auto item = CurrentThreadQueue::QueueItem(dueTime, std::move(work)); + bool isOwner = false; + + { + std::unique_lock guard(lock); + if (!hasFaulted && !queue && !isAquired) + { + queue = CurrentThreadQueue::CreateQueue(this->shared_from_this()).release(); + isOwner = !isAquired; + isAquired = true; + } + } + + if (isOwner) + { + RXCPP_UNWIND_AUTO([&](){ + std::unique_lock guard(lock); + CurrentThreadQueue::DestroyQueue(queue); + queue = nullptr; + isAquired = false; + }); + + for(;;) + { + std::this_thread::sleep_until(item.due); + try + { + Do(item.work, queue->scheduler); + } + catch (...) + { + std::unique_lock guard(lock); + while (!queue->queue.empty()) {queue->queue.pop();} + hasFaulted = true; + throw; + } + + { + std::unique_lock guard(lock); + if (queue->queue.empty()) + { + break; + } + item = std::move(queue->queue.top()); + queue->queue.pop(); + } + } + return Disposable::Empty(); + } + else + { + std::unique_lock guard(lock); + queue->queue.push(item); + return item.work; + } } }; @@ -223,30 +277,24 @@ namespace rxcpp typedef std::function Action; Scheduler::shared scheduler; - std::atomic trampoline; mutable std::shared_ptr> observer; mutable SerialDisposable sd; mutable std::queue queue; mutable std::mutex lock; + mutable bool hasFaulted; + mutable bool isAquired; public: ScheduledObserver(Scheduler::shared scheduler, std::shared_ptr> observer) : scheduler(std::move(scheduler)) - , trampoline(0) , observer(std::move(observer)) + , hasFaulted(false) + , isAquired(false) { } void Dispose() const { - SerialDisposable sd; - { - std::unique_lock guard(lock); - while (!queue.empty()) {queue.pop();} - using std::swap; - swap(sd, this->sd); - observer= nullptr; - } sd.Dispose(); } operator Disposable() const @@ -260,86 +308,83 @@ namespace rxcpp virtual void OnNext(const T& element) { std::unique_lock guard(lock); - auto local = this->shared_from_this(); queue.push(Action([=](){ - std::unique_lock guard(lock); - auto o = local->observer; - guard.unlock(); - if (o){ - o->OnNext(std::move(element)); - }})); + observer->OnNext(std::move(element)); + })); } virtual void OnCompleted() { std::unique_lock guard(lock); - auto local = this->shared_from_this(); queue.push(Action([=](){ - std::unique_lock guard(lock); - auto o = local->observer; - guard.unlock(); - if (o){ - o->OnCompleted(); - }})); + observer->OnCompleted(); + })); } virtual void OnError(const std::exception_ptr& error) { std::unique_lock guard(lock); - auto local = this->shared_from_this(); queue.push(Action([=](){ - std::unique_lock guard(lock); - auto o = local->observer; - guard.unlock(); - if (o){ - o->OnError(std::move(error)); - }})); + observer->OnError(std::move(error)); + })); } void EnsureActive() { - RXCPP_UNWIND_AUTO([&]{--trampoline;}); - if (++trampoline == 1) + bool isOwner = false; + + { + std::unique_lock guard(lock); + if (!hasFaulted && !queue.empty()) + { + isOwner = !isAquired; + isAquired = true; + } + } + + if (isOwner) { - // this is decremented when no further work is scheduled - ++trampoline; auto keepAlive = this->shared_from_this(); sd.Set(scheduler->Schedule( [keepAlive](Scheduler::shared sched){ return keepAlive->Run(sched);})); } } + private: Disposable Run(Scheduler::shared sched) { auto keepAlive = this->shared_from_this(); - std::unique_lock guard(lock); + Action action; + { + std::unique_lock guard(lock); + if(!queue.empty()) + { + action = std::move(queue.front()); + queue.pop(); + } + else + { + isAquired = false; + return Disposable::Empty(); + } + } - if(!queue.empty()) + try { - auto& item = queue.front(); - - // dispatch action - auto action = std::move(item); - item = nullptr; - queue.pop(); - - RXCPP_UNWIND_AUTO([&]{guard.lock();}); - guard.unlock(); action(); } - - if(!queue.empty()) + catch (...) { - guard.unlock(); - sd.Set(sched->Schedule( - [keepAlive](Scheduler::shared sched){ - return keepAlive->Run(sched);})); - return sd; + std::unique_lock guard(lock); + while (!queue.empty()) {queue.pop();} + hasFaulted = true; + throw; } - // only decrement when no further work is scheduled - --trampoline; - return Disposable::Empty(); + sd.Set(sched->Schedule( + [keepAlive](Scheduler::shared sched){ + return keepAlive->Run(sched);})); + return sd; } }; @@ -353,14 +398,14 @@ namespace rxcpp private: Derecurser(const Derecurser&); - std::atomic trampoline; + mutable bool isAquired; mutable std::mutex lock; mutable std::condition_variable wake; CurrentThreadQueue::ThreadLocalQueue* queue; public: Derecurser() - : trampoline(0) + : isAquired(false) { } virtual ~Derecurser() @@ -375,38 +420,40 @@ namespace rxcpp typedef std::tuple, Disposable> EnsureThreadResult; EnsureThreadResult EnsureThread(Factory& factory, Scheduler::shared owner, clock::time_point dueTime, Work work) { + bool isOwner = false; EnsureThreadResult result(util::maybe(), Disposable::Empty()); - auto cancelable = std::make_shared(std::move(work)); - std::get<1>(result) = Disposable([cancelable]{ - *cancelable.get() = nullptr;}); + // work is disposable + std::get<1>(result) = work; std::unique_lock guard(lock); - RXCPP_UNWIND(unwindTrampoline, [&]{ - --trampoline;}); - if (++trampoline == 1) + if (!isAquired) { RXCPP_UNWIND(unwindQueue, [&](){ CurrentThreadQueue::DestroyQueue(queue); queue = nullptr;}); queue = CurrentThreadQueue::CreateQueue(owner).release(); - queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); + queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(work))); auto local = std::static_pointer_cast(shared_from_this()); auto localQueue = queue; std::get<0>(result).set(factory([local, localQueue]{ local->Run(localQueue);})); - // trampoline and queue lifetime is now owned by the thread - unwindTrampoline.dismiss(); + isOwner = !isAquired; + isAquired = true; + + // queue lifetime is now owned by the thread unwindQueue.dismiss(); } - else + + if (!isOwner) { - queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(cancelable))); + queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(work))); wake.notify_one(); } + return std::move(result); } @@ -414,20 +461,22 @@ namespace rxcpp void Run(CurrentThreadQueue::ThreadLocalQueue* queue) { auto keepAlive = shared_from_this(); { - RXCPP_UNWIND_AUTO([&]{ - --trampoline;}); - std::unique_lock guard(lock); - CurrentThreadQueue::SetQueue(queue); + RXCPP_UNWIND_AUTO([&]{ + isAquired = false;}); + RXCPP_UNWIND(unwindQueue, [&](){ CurrentThreadQueue::DestroyQueue(); queue = nullptr;}); + + CurrentThreadQueue::SetQueue(queue); + #if 0 auto start = queue->scheduler->Now(); auto ms = std::chrono::milliseconds(1); #endif - while(!CurrentThreadQueue::empty() || trampoline > 1) + while(!CurrentThreadQueue::empty()) { auto now = queue->scheduler->Now(); #if 0 @@ -448,12 +497,12 @@ namespace rxcpp OutputDebugString(out.str().c_str());} #endif wake.wait(guard, [&](){ - return !CurrentThreadQueue::empty() || trampoline == 1;}); + return !CurrentThreadQueue::empty();}); continue; } auto item = &CurrentThreadQueue::top(); - if (!item->work || !*item->work.get()) { + if (!item->work) { #if 0 {std::wstringstream out; out << L"eventloop (pop disposed work) pending: " << std::boolalpha << CurrentThreadQueue::empty() @@ -490,8 +539,8 @@ namespace rxcpp OutputDebugString(out.str().c_str());} #endif // dispatch work - auto work = std::move(*item->work.get()); - *item->work.get() = nullptr; + auto work = item->work; + CurrentThreadQueue::pop(); RXCPP_UNWIND_AUTO([&]{ @@ -622,7 +671,7 @@ namespace rxcpp util::maybe next; while (!queue.empty()) { next.set(queue.top()); - if (!next->work || !*next->work) { + if (!next->work) { queue.pop(); } else { @@ -634,23 +683,20 @@ namespace rxcpp Disposable ScheduleAbsolute(Absolute dueTime, Work work) { - auto cancelable = std::make_shared(); + Work cancelable; auto run = [cancelable, work](Scheduler::shared scheduler) -> Disposable { auto local = work; - *cancelable.get() = nullptr; + cancelable.Dispose(); return Base::Do(local, std::move(scheduler)); }; - *cancelable.get() = run; + cancelable = run; auto si = QueueItem(dueTime, cancelable); queue.push(si); - auto result = Disposable([cancelable]{ - *cancelable.get() = nullptr; - }); - return result; + return cancelable; } }; -- GitLab From 9a44c66b9e9d095d61847b22985b3ad14597da54 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 01:22:53 -0800 Subject: [PATCH 134/782] add isStopped to non-variadic path --- Rx/CPP/src/cpprx/operators/Zip.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Rx/CPP/src/cpprx/operators/Zip.hpp b/Rx/CPP/src/cpprx/operators/Zip.hpp index 13a7b0f..8788bbc 100644 --- a/Rx/CPP/src/cpprx/operators/Zip.hpp +++ b/Rx/CPP/src/cpprx/operators/Zip.hpp @@ -199,10 +199,12 @@ namespace rxcpp typedef std::tuple_size SourcesSize; explicit State(S selector) : selector(std::move(selector)) + , isStopped(false) {} std::mutex lock; S selector; Queues queues; + bool isStopped; }; Sources sources(source1, source2); // bug on osx prevents using make_shared -- GitLab From 3ecc8f259e399e7112cb5fd5717bd7a7b7afb57a Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 01:24:10 -0800 Subject: [PATCH 135/782] add bug fixes for issues found on windows --- Rx/CPP/src/cpprx/rx-operators.hpp | 10 ++++++++-- Rx/CPP/src/cpprx/rx-scheduler.hpp | 3 ++- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index fdd81f7..97e9bc4 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -189,6 +189,9 @@ namespace rxcpp typedef std::shared_ptr> SinkObserver; mutable util::maybe cancel; + // need to prevent disposed observer from being + // deleted since it may still be in use on the stack + mutable SinkObserver expired; protected: mutable SinkObserver observer; @@ -205,7 +208,10 @@ namespace rxcpp void Dispose() const { - observer = std::make_shared>(); + expired = std::make_shared>(); + using std::swap; + swap(observer, expired); + if (cancel) { cancel->Dispose(); @@ -782,7 +788,7 @@ namespace rxcpp return Disposable([that]() { std::unique_lock guard(that->lock); - if (that->subscription) + if (!!that->subscription) { that->subscription->Dispose(); that->subscription.reset(); diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index cac1534..5f13d71 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -952,7 +952,8 @@ namespace rxcpp for (auto& message : messages) { auto notification = message.Value(); scheduler->ScheduleAbsolute(message.Time(), [this, notification](Scheduler::shared) -> Disposable { - for (auto& observer : this->observers) { + auto local = this->observers; + for (auto& observer : local) { notification->Accept(observer); } return Disposable::Empty(); -- GitLab From 7f4becf53bac4e22c763694418dff4284258d0f1 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 09:47:59 -0800 Subject: [PATCH 136/782] Wow, that was compiling - until now.. --- Rx/CPP/src/cpprx/operators/Take.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/operators/Take.hpp b/Rx/CPP/src/cpprx/operators/Take.hpp index 2ffec60..5085d9a 100644 --- a/Rx/CPP/src/cpprx/operators/Take.hpp +++ b/Rx/CPP/src/cpprx/operators/Take.hpp @@ -121,7 +121,7 @@ namespace rxcpp cd.Add(Subscribe( terminus, // on next - [=](const T& element) + [=](const U& element) { state->terminusState = TerminusState::Terminated; }, -- GitLab From 3953440f4139bd1fff0dabe4aad67f7a51d73ce4 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 09:49:38 -0800 Subject: [PATCH 137/782] Fix to avoid ICE --- Rx/CPP/src/cpprx/operators/CombineLatest.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp index cf5af07..d847f9b 100644 --- a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp +++ b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp @@ -31,7 +31,7 @@ namespace rxcpp --state->pendingFirst; } if (state->pendingFirst == 0) { - Latest args = state->latest; + auto args = state->latest; typedef decltype(util::tuple_dispatch(state->selector, args)) U; util::maybe result; try { -- GitLab From e806fc9fa74ca8c835196d26c1983a710a9bba0c Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 09:53:05 -0800 Subject: [PATCH 138/782] Fix to avoid ICE in lambdas missing 'this->' --- Rx/CPP/src/cpprx/rx-operators.hpp | 12 ++++++------ Rx/CPP/src/cpprx/rx-scheduler.hpp | 6 +++--- Rx/CPP/src/cpprx/rx-winrt.hpp | 16 ++++++++-------- 3 files changed, 17 insertions(+), 17 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 97e9bc4..b972ea7 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -35,8 +35,8 @@ namespace rxcpp if (!isStopped) { auto keepAlive = this->shared_from_this(); RXCPP_UNWIND(disposer, [&](){ - isStopped = true; - disposable.Dispose(); + this->isStopped = true; + this->disposable.Dispose(); }); observer->OnNext(element); disposer.dismiss(); @@ -47,7 +47,7 @@ namespace rxcpp if (!isStopped.exchange(true)) { auto keepAlive = this->shared_from_this(); RXCPP_UNWIND(disposer, [&](){ - disposable.Dispose(); + this->disposable.Dispose(); }); observer->OnCompleted(); } @@ -57,7 +57,7 @@ namespace rxcpp if (!isStopped.exchange(true)) { auto keepAlive = this->shared_from_this(); RXCPP_UNWIND(disposer, [&](){ - disposable.Dispose(); + this->disposable.Dispose(); }); observer->OnError(error); } @@ -107,7 +107,7 @@ namespace rxcpp scheduler->Schedule( [=](Scheduler::shared) -> Disposable { try { - autoDetachObserver->disposable.Set(subscribe(autoDetachObserver)); + autoDetachObserver->disposable.Set(this->subscribe(autoDetachObserver)); } catch (...) { autoDetachObserver->OnError(std::current_exception()); } @@ -259,7 +259,7 @@ namespace rxcpp scheduler->Schedule([=](Scheduler::shared) -> Disposable { state->subscription.Set( - run(that, observer, state->subscription, [=](Disposable d) + this->run(that, observer, state->subscription, [=](Disposable d) { state->sink.Set(std::move(d)); })); diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 5f13d71..410c168 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -309,21 +309,21 @@ namespace rxcpp { std::unique_lock guard(lock); queue.push(Action([=](){ - observer->OnNext(std::move(element)); + this->observer->OnNext(std::move(element)); })); } virtual void OnCompleted() { std::unique_lock guard(lock); queue.push(Action([=](){ - observer->OnCompleted(); + this->observer->OnCompleted(); })); } virtual void OnError(const std::exception_ptr& error) { std::unique_lock guard(lock); queue.push(Action([=](){ - observer->OnError(std::move(error)); + this->observer->OnError(std::move(error)); })); } diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp index 2e743b9..061e351 100644 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ b/Rx/CPP/src/cpprx/rx-winrt.hpp @@ -403,19 +403,19 @@ namespace rxcpp { namespace winrt { // select collection [=](T t) { - std::unique_lock guard(flight_lock); - inflight->OnNext(true); + std::unique_lock guard(this->flight_lock); + this->inflight->OnNext(true); return Using( // resource factory [=]() -> SerialDisposable { SerialDisposable flight; flight.Set(ScheduledDisposable( - defaultScheduler, + this->defaultScheduler, Disposable([=]() { - std::unique_lock guard(flight_lock); - inflight->OnNext(false); + std::unique_lock guard(this->flight_lock); + this->inflight->OnNext(false); }))); return flight; }, @@ -470,7 +470,7 @@ namespace rxcpp { namespace winrt { } catch (...) { - exceptions->OnError(std::current_exception()); + this->exceptions->OnError(std::current_exception()); } }, //on completed @@ -481,7 +481,7 @@ namespace rxcpp { namespace winrt { } catch (...) { - exceptions->OnError(std::current_exception()); + this->exceptions->OnError(std::current_exception()); } }, //on error @@ -492,7 +492,7 @@ namespace rxcpp { namespace winrt { } catch (...) { - exceptions->OnError(std::current_exception()); + this->exceptions->OnError(std::current_exception()); } }); } -- GitLab From 779b3e21e661e55ae6265e240fc0c5bcf8f6aa7f Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 09:54:25 -0800 Subject: [PATCH 139/782] Fix to avoid ICE by adding 'Class::' in lambda --- Rx/CPP/src/cpprx/operators/RefCount.hpp | 2 +- Rx/CPP/src/cpprx/operators/Return.hpp | 2 +- Rx/CPP/src/cpprx/operators/Scan.hpp | 2 +- Rx/CPP/src/cpprx/operators/Throw.hpp | 2 +- Rx/CPP/src/cpprx/operators/Where.hpp | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/RefCount.hpp b/Rx/CPP/src/cpprx/operators/RefCount.hpp index 22a8224..9638ca1 100644 --- a/Rx/CPP/src/cpprx/operators/RefCount.hpp +++ b/Rx/CPP/src/cpprx/operators/RefCount.hpp @@ -79,7 +79,7 @@ namespace rxcpp RefCountObservable(std::shared_ptr> source) : ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable&& cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::shared_ptr<_>(new _(that, observer, std::move(cancel))); + auto sink = std::shared_ptr(new RefCountObservable::_(that, observer, std::move(cancel))); setSink(sink->GetDisposable()); return sink->Run(); }), diff --git a/Rx/CPP/src/cpprx/operators/Return.hpp b/Rx/CPP/src/cpprx/operators/Return.hpp index cb97075..924492f 100644 --- a/Rx/CPP/src/cpprx/operators/Return.hpp +++ b/Rx/CPP/src/cpprx/operators/Return.hpp @@ -51,7 +51,7 @@ namespace rxcpp ReturnObservable(T value, Scheduler::shared scheduler) : ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + auto sink = std::shared_ptr(new ReturnObservable::_(parent, observer, std::move(cancel))); setSink(sink->GetDisposable()); return sink->Run(); }), diff --git a/Rx/CPP/src/cpprx/operators/Scan.hpp b/Rx/CPP/src/cpprx/operators/Scan.hpp index 6247c8e..fa3b00c 100644 --- a/Rx/CPP/src/cpprx/operators/Scan.hpp +++ b/Rx/CPP/src/cpprx/operators/Scan.hpp @@ -85,7 +85,7 @@ namespace rxcpp ScanObservable(Source source, util::maybe seed, Accumulator accumulator, Seeder seeder) : ProducerBase([this](Parent parent, std::shared_ptr < Observer < A >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + auto sink = std::shared_ptr(new ScanObservable::_(parent, observer, std::move(cancel))); setSink(sink->GetDisposable()); return this->source->Subscribe(sink); }), diff --git a/Rx/CPP/src/cpprx/operators/Throw.hpp b/Rx/CPP/src/cpprx/operators/Throw.hpp index df94880..13530d3 100644 --- a/Rx/CPP/src/cpprx/operators/Throw.hpp +++ b/Rx/CPP/src/cpprx/operators/Throw.hpp @@ -52,7 +52,7 @@ namespace rxcpp ThrowObservable(std::exception_ptr exception, Scheduler::shared scheduler) : ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + auto sink = std::shared_ptr(new ThrowObservable::_(parent, observer, std::move(cancel))); setSink(sink->GetDisposable()); return sink->Run(); }), diff --git a/Rx/CPP/src/cpprx/operators/Where.hpp b/Rx/CPP/src/cpprx/operators/Where.hpp index 5119cb3..d0089bd 100644 --- a/Rx/CPP/src/cpprx/operators/Where.hpp +++ b/Rx/CPP/src/cpprx/operators/Where.hpp @@ -63,7 +63,7 @@ namespace rxcpp WhereObservable(const std::shared_ptr>& source, Predicate predicate) : ProducerBase([this](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + auto sink = std::shared_ptr(new WhereObservable::_(parent, observer, std::move(cancel))); setSink(sink->GetDisposable()); return this->source->Subscribe(sink); }), -- GitLab From ece7187a87ae9bf730c0f89bdd7b0d4a247f0c11 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 09:55:07 -0800 Subject: [PATCH 140/782] Fix to avoid ICE (moved Source source to class member) --- Rx/CPP/src/cpprx/operators/Using.hpp | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Using.hpp b/Rx/CPP/src/cpprx/operators/Using.hpp index 634bfc6..d435d75 100644 --- a/Rx/CPP/src/cpprx/operators/Using.hpp +++ b/Rx/CPP/src/cpprx/operators/Using.hpp @@ -11,16 +11,16 @@ namespace rxcpp namespace detail { - template - class UsingObservable : public Producer, T> + template + class UsingObservable : public Producer, T> { - typedef UsingObservable This; + typedef UsingObservable This; typedef std::shared_ptr Parent; - typedef std::shared_ptr> Source; + typedef typename std::decay::type Source; public: typedef std::function ResourceFactory; - typedef std::function ObservableFactory; + typedef std::function ObservableFactory; private: ResourceFactory resourceFactory; @@ -29,6 +29,7 @@ namespace rxcpp class _ : public Sink<_, T>, public Observer { Parent parent; + Source source; public: typedef Sink<_, T> SinkBase; @@ -42,7 +43,6 @@ namespace rxcpp Disposable Run() { ComposableDisposable cd; - Source source; auto disposable = Disposable::Empty(); try @@ -85,7 +85,7 @@ namespace rxcpp UsingObservable(ResourceFactory resourceFactory, ObservableFactory observableFactory) : ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); + auto sink = std::shared_ptr(new UsingObservable::_(parent, observer, std::move(cancel))); setSink(sink->GetDisposable()); return sink->Run(); }), @@ -102,9 +102,10 @@ namespace rxcpp ) -> decltype(observableFactory(resourceFactory())) { - typedef typename observable_item::type T; + typedef decltype(observableFactory(resourceFactory())) ScopedObservable; + typedef typename observable_item::type T; typedef decltype(resourceFactory()) R; - return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); + return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); } } -- GitLab From 058f75e8bca0c493db3e2c3ebf41f0a44138bd33 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 18:32:10 -0800 Subject: [PATCH 141/782] add CMake build --- projects/CMake/CMakeLists.txt | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 projects/CMake/CMakeLists.txt diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt new file mode 100644 index 0000000..866beec --- /dev/null +++ b/projects/CMake/CMakeLists.txt @@ -0,0 +1,26 @@ +cmake_minimum_required(VERSION 2.8) + +project(rxcpp) + +MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) + +if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + list( APPEND CMAKE_CXX_FLAGS " -std=c++0x ${CMAKE_CXX_FLAGS}") +elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + list( APPEND CMAKE_CXX_FLAGS " -std=c++0x ${CMAKE_CXX_FLAGS}") +elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + list( APPEND CMAKE_CXX_FLAGS " /DUNICODE /D_UNICODE /bigobj ${CMAKE_CXX_FLAGS}") +endif() + +# define some folders +get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) +set(TEST_DIR ${RXCPP_DIR}/Rx/CPP/test) + +include_directories(${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/CPP/src) + +# define the sources of testbench +set(TESTBENCH_SOURCES + ${RXCPP_DIR}/Rx/CPP/testbench/testbench.cpp +) +add_executable(testbench ${TESTBENCH_SOURCES}) -- GitLab From 8fe8f8e4c341a336389bd3839709a4be1b0721ac Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 7 Dec 2013 01:08:41 -0800 Subject: [PATCH 142/782] fixes root cause of the ices --- Rx/CPP/src/cpprx/rx.hpp | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index b1a32cd..bddfd96 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -240,16 +240,24 @@ namespace detail { } #endif //RXCPP_USE_VARIADIC_TEMPLATES #if RXCPP_USE_VARIADIC_TEMPLATES - template - auto combine_latest(S selector, const CombineLSource&... source) - -> typename std::enable_if::value, decltype(from(CombineLatest(selector, obj, observable(source)...)))>::type { - return from(CombineLatest(selector, obj, observable(source)...)); - } - template - auto combine_latest(const CombineL1Source& source, const CombineL1SourceN&... sourcen) - -> typename std::enable_if < is_observable::value, - decltype(from(CombineLatest(util::as_tuple(), obj, observable(source), observable(sourcen)...)))>::type { - return from(CombineLatest(util::as_tuple(), obj, observable(source), observable(sourcen)...)); + private: + struct selector_tag{}; + struct source_tag{}; + template + auto combine_latest_detail(selector_tag&&, CombineSelector&& selector, const CombineSelectorSources&... sources) + -> decltype(from(CombineLatest(std::forward(selector), obj, observable(sources)...))) { + return from(CombineLatest(std::forward(selector), obj, observable(sources)...)); + } + template + auto combine_latest_detail(source_tag&&, const CombineSourceSources&... sources) + -> decltype(from(CombineLatest(util::as_tuple(), obj, observable(sources)...))) { + return from(CombineLatest(util::as_tuple(), obj, observable(sources)...)); + } + public: + template + auto combine_latest(CombineSourceOrSelector&& sourceOrSelector, const CombineSourceN&... sourcen) + -> decltype(from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), std::forward(sourcen)...))) { + return from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), std::forward(sourcen)...)); } #else template -- GitLab From 0497a527a8dd38720d3bc4ae69e11dd722eec5cc Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 7 Dec 2013 01:09:27 -0800 Subject: [PATCH 143/782] return defaults to immediate --- Rx/CPP/src/cpprx/operators/Return.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/operators/Return.hpp b/Rx/CPP/src/cpprx/operators/Return.hpp index 924492f..da3b49b 100644 --- a/Rx/CPP/src/cpprx/operators/Return.hpp +++ b/Rx/CPP/src/cpprx/operators/Return.hpp @@ -60,7 +60,7 @@ namespace rxcpp { if (!scheduler) { - this->scheduler = std::make_shared(); + this->scheduler = std::make_shared(); } } }; -- GitLab From fd41f8489b3d455cdff1e44ee95bbf39d4920d3a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 7 Dec 2013 01:09:59 -0800 Subject: [PATCH 144/782] add never operator --- Rx/CPP/src/cpprx/operators/Never.hpp | 22 ++++++++++++++++++++++ Rx/CPP/src/cpprx/rx-operators.hpp | 1 + 2 files changed, 23 insertions(+) create mode 100644 Rx/CPP/src/cpprx/operators/Never.hpp diff --git a/Rx/CPP/src/cpprx/operators/Never.hpp b/Rx/CPP/src/cpprx/operators/Never.hpp new file mode 100644 index 0000000..ffdd831 --- /dev/null +++ b/Rx/CPP/src/cpprx/operators/Never.hpp @@ -0,0 +1,22 @@ + // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once +#include "../rx-operators.hpp" + +#if !defined(CPPRX_RX_OPERATORS_NEVER_HPP) +#define CPPRX_RX_OPERATORS_NEVER_HPP + +namespace rxcpp +{ + template + std::shared_ptr> Never() + { + return CreateObservable( + [=](std::shared_ptr>) -> Disposable + { + return Disposable::Empty(); + }); + } +} + +#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index b972ea7..0a8d0b1 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -827,6 +827,7 @@ namespace rxcpp #include "operators/Subscribe.hpp" #include "operators/ForEach.hpp" #include "operators/Empty.hpp" +#include "operators/Never.hpp" #include "operators/Return.hpp" #include "operators/Throw.hpp" #include "operators/Range.hpp" -- GitLab From 80c46fc0fbde9574b383b5f9b66844845722399a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 7 Dec 2013 11:33:37 -0800 Subject: [PATCH 145/782] fix for SkipUntil --- Rx/CPP/src/cpprx/operators/Skip.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/operators/Skip.hpp b/Rx/CPP/src/cpprx/operators/Skip.hpp index fb27dbb..e635b71 100644 --- a/Rx/CPP/src/cpprx/operators/Skip.hpp +++ b/Rx/CPP/src/cpprx/operators/Skip.hpp @@ -88,7 +88,7 @@ namespace rxcpp cd.Add(Subscribe( terminus, // on next - [=](const T& element) + [=](const U& element) { state->skipState = SkipState::Taking; }, -- GitLab From 2633f247e73dcb7c0aabcac91e420cf8ed6a5277 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Dec 2013 09:34:47 -0800 Subject: [PATCH 146/782] misplaced forward --- Rx/CPP/src/cpprx/rx.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index bddfd96..eab8c1b 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -256,8 +256,8 @@ namespace detail { public: template auto combine_latest(CombineSourceOrSelector&& sourceOrSelector, const CombineSourceN&... sourcen) - -> decltype(from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), std::forward(sourcen)...))) { - return from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), std::forward(sourcen)...)); + -> decltype(from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), sourcen...))) { + return from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), sourcen...)); } #else template -- GitLab From af7a85a92d177226b72ccf77c25009f8eecdba86 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 12:47:56 -0800 Subject: [PATCH 147/782] add travis ci status --- .travis.yml | 18 ++++++++++++++++++ README.md | 6 ++++-- 2 files changed, 22 insertions(+), 2 deletions(-) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..65065ce --- /dev/null +++ b/.travis.yml @@ -0,0 +1,18 @@ +language: cpp + +compiler: + - clang + +env: + - BUILD_TYPE=Debug + - BUILD_TYPE=Release + +install: + - cmake -Hprojects/CMake -BBuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE + - cd Build + - make + - cd .. + +script: + - cd Build + - ctest -V diff --git a/README.md b/README.md index bb32490..122be88 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # Reactive Extensions: +Rxcpp Build status [![Build Status](https://travis-ci.org/Reactive-Extensions/RxCpp.png)](https://travis-ci.org/Reactive-Extensions/RxCpp) + * Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. * RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. * Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. @@ -15,6 +17,6 @@ #Contributing Code -Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. +Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. -You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. \ No newline at end of file +You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. -- GitLab From f574b0b1536b96a1086afb0ae1c896f56bbefc92 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 13:12:07 -0800 Subject: [PATCH 148/782] allow fallback to monotonic_clock --- Rx/CPP/src/cpprx/rx-base.hpp | 2 +- Rx/CPP/src/cpprx/rx-util.hpp | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 1c10226..d5ed9c5 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -74,7 +74,7 @@ namespace rxcpp struct Scheduler : public std::enable_shared_from_this { - typedef std::chrono::steady_clock clock; + typedef util::scheduler_clock clock; typedef std::shared_ptr shared; class Work { diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index 92ef223..eafdd22 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -132,6 +132,13 @@ namespace rxcpp { namespace util { template struct reveal_type {private: reveal_type();}; + + template + auto find_clock(T, int) -> std::chrono::steady_clock; + template + auto find_clock(T, ...) -> std::chrono::monotonic_clock; + typedef decltype(find_clock(0, 0)) scheduler_clock; + #if RXCPP_USE_VARIADIC_TEMPLATES template struct tuple_indices; -- GitLab From cc22364bc86daa7fb2e19ecdf4758429e16dbd87 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 13:12:29 -0800 Subject: [PATCH 149/782] remove incomplete limitwindow operator --- Rx/CPP/src/cpprx/rx-operators.hpp | 48 ------------------------------- Rx/CPP/src/cpprx/rx.hpp | 3 -- 2 files changed, 51 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index 0a8d0b1..a216573 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -879,54 +879,6 @@ namespace rxcpp namespace rxcpp { - - // no more than one event ever 'milliseconds' - // TODO: oops, this is not the right definition for throttle. - template - std::shared_ptr> LimitWindow( - const std::shared_ptr>& source, - int milliseconds) - { - if (milliseconds == 0) - return source; - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - std::chrono::steady_clock::time_point dueTime; - }; - - auto state = std::make_shared(); - - return Subscribe( - source, - // on next - [=](const T& element) - { - auto now = std::chrono::steady_clock::now(); - - if (now >= state->dueTime) - { - observer->OnNext(element); - state->dueTime = now + std::chrono::duration(milliseconds); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } - - class StdQueueDispatcher { mutable std::queue> pending; diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp index eab8c1b..16bfcc1 100644 --- a/Rx/CPP/src/cpprx/rx.hpp +++ b/Rx/CPP/src/cpprx/rx.hpp @@ -399,9 +399,6 @@ namespace detail { -> decltype(from(Throttle(obj, due, scheduler))) { return from(Throttle(obj, due, scheduler)); } - auto limit_window(int milliseconds) -> decltype(from(LimitWindow(obj, milliseconds))) { - return from(LimitWindow(obj, milliseconds)); - } auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { return from(DistinctUntilChanged(obj)); } -- GitLab From e6112126769e226b07751facac68f52cd5d4949d Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 13:30:04 -0800 Subject: [PATCH 150/782] Revert "allow fallback to monotonic_clock" This reverts commit f574b0b1536b96a1086afb0ae1c896f56bbefc92. --- Rx/CPP/src/cpprx/rx-base.hpp | 2 +- Rx/CPP/src/cpprx/rx-util.hpp | 7 ------- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index d5ed9c5..1c10226 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -74,7 +74,7 @@ namespace rxcpp struct Scheduler : public std::enable_shared_from_this { - typedef util::scheduler_clock clock; + typedef std::chrono::steady_clock clock; typedef std::shared_ptr shared; class Work { diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp index eafdd22..92ef223 100644 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ b/Rx/CPP/src/cpprx/rx-util.hpp @@ -132,13 +132,6 @@ namespace rxcpp { namespace util { template struct reveal_type {private: reveal_type();}; - - template - auto find_clock(T, int) -> std::chrono::steady_clock; - template - auto find_clock(T, ...) -> std::chrono::monotonic_clock; - typedef decltype(find_clock(0, 0)) scheduler_clock; - #if RXCPP_USE_VARIADIC_TEMPLATES template struct tuple_indices; -- GitLab From a960488c80e5e39903992548fcee4113c00f8eda Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 17 Dec 2013 15:26:03 -0800 Subject: [PATCH 151/782] fix unused parameter warning --- Rx/CPP/src/cpprx/operators/Take.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Take.hpp b/Rx/CPP/src/cpprx/operators/Take.hpp index 5085d9a..20187d4 100644 --- a/Rx/CPP/src/cpprx/operators/Take.hpp +++ b/Rx/CPP/src/cpprx/operators/Take.hpp @@ -121,7 +121,7 @@ namespace rxcpp cd.Add(Subscribe( terminus, // on next - [=](const U& element) + [=](const U& ) { state->terminusState = TerminusState::Terminated; }, @@ -131,7 +131,7 @@ namespace rxcpp state->terminusState = TerminusState::Terminated; }, // on error - [=](const std::exception_ptr& error) + [=](const std::exception_ptr& ) { state->terminusState = TerminusState::Terminated; })); -- GitLab From 104c0e5f9f37bb33a5e30bdbb60efc0fa879f5c6 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 17 Dec 2013 15:26:41 -0800 Subject: [PATCH 152/782] fix assignment on a moved-from Work. --- Rx/CPP/src/cpprx/rx-base.hpp | 82 ++++++++++++++++++++---------------- 1 file changed, 45 insertions(+), 37 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 1c10226..609265c 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -9,7 +9,7 @@ namespace rxcpp { ////////////////////////////////////////////////////////////////////// - // + // // Abstract interfaces template @@ -29,14 +29,14 @@ namespace rxcpp typedef std::function dispose_type; dispose_type dispose; public: - explicit Disposable(dispose_type disposearg) + explicit Disposable(dispose_type disposearg) : dispose(std::move(disposearg)) { disposearg = nullptr;} - Disposable(Disposable&& other) + Disposable(Disposable&& other) : dispose(std::move(other.dispose)) { other.dispose = nullptr; } Disposable& operator=(Disposable other) { - swap(other); + swap(other); return *this; } void Dispose() @@ -78,7 +78,7 @@ namespace rxcpp typedef std::shared_ptr shared; class Work { - struct bool_r{}; + struct bool_r{}; static bool_r bool_true(){return bool_r();} typedef decltype(&bool_true) bool_type; @@ -94,11 +94,19 @@ namespace rxcpp std::shared_ptr state; template - struct assign + struct assign { - void operator()(const std::shared_ptr& state, State::F fn) { + void operator()(std::shared_ptr& state, State::F fn) { + if (!state) { + state = std::make_shared(); + } state->work = std::move(fn); } + void operator()(std::shared_ptr& state, std::nullptr_t) { + if (state) { + state->work = nullptr; + } + } }; template @@ -129,11 +137,11 @@ namespace rxcpp { assign<1, std::is_same::type>::value>()(state, std::forward(fn)); return *this; - } + } inline Disposable operator()(shared s) { if (!state->disposed) { return state->work(s); - } + } return Disposable::Empty(); } inline operator bool_type() const {return (!state->disposed && !!state->work) ? &bool_true : nullptr;} @@ -161,10 +169,10 @@ namespace rxcpp }; ////////////////////////////////////////////////////////////////////// - // + // // disposables - + // reference handle type for a container for composing disposables class ComposableDisposable { @@ -175,7 +183,7 @@ namespace rxcpp std::vector disposables; std::mutex lock; bool isDisposed; - + State() : isDisposed(false) { } @@ -199,11 +207,11 @@ namespace rxcpp } return s; } - void Remove(weak_disposable w) + void Remove(weak_disposable w) { std::unique_lock guard(lock); auto s = w.lock(); - if (s) + if (s) { auto end = std::end(disposables); auto it = std::find(std::begin(disposables), end, s); @@ -222,16 +230,16 @@ namespace rxcpp isDisposed = true; auto v = std::move(disposables); guard.unlock(); - + std::for_each(v.begin(), v.end(), - [](shared_disposable& d) { + [](shared_disposable& d) { d->Dispose(); }); } } }; - + mutable std::shared_ptr state; - + public: ComposableDisposable() @@ -272,8 +280,8 @@ namespace rxcpp { Scheduler::shared scheduler; Disposable disposable; - - State(Scheduler::shared scheduler, Disposable disposable) + + State(Scheduler::shared scheduler, Disposable disposable) : scheduler(std::move(scheduler)) , disposable(std::move(disposable)) { @@ -290,13 +298,13 @@ namespace rxcpp } } }; - + std::shared_ptr state; - + ScheduledDisposable(); public: - ScheduledDisposable(Scheduler::shared scheduler, Disposable disposable) + ScheduledDisposable(Scheduler::shared scheduler, Disposable disposable) : state(new State(std::move(scheduler), std::move(disposable))) { } @@ -332,7 +340,7 @@ namespace rxcpp class SerialDisposable { - struct State + struct State { mutable Disposable disposable; mutable bool disposed; @@ -341,10 +349,10 @@ namespace rxcpp State() : disposable(Disposable::Empty()), disposed(false) {} void Set(Disposable disposeArg) const - { + { std::unique_lock guard(lock); if (!disposed) { - using std::swap; + using std::swap; swap(disposable, disposeArg); } guard.unlock(); @@ -361,12 +369,12 @@ namespace rxcpp } } }; - + mutable std::shared_ptr state; - + public: - SerialDisposable() + SerialDisposable() : state(std::make_shared()) { } @@ -439,7 +447,7 @@ namespace rxcpp clock::time_point dueTime = clock::now(); return Schedule(dueTime, std::move(work)); } - + virtual Disposable Schedule(clock::duration due, Work work) { clock::time_point dueTime = clock::now() + due; @@ -508,7 +516,7 @@ namespace rxcpp { return ScheduleAbsolute(clock_now, std::move(work)); } - + virtual Disposable Schedule(clock::duration due, Work work) { return ScheduleRelative(ToRelative(due), std::move(work)); @@ -655,7 +663,7 @@ namespace rxcpp } template - struct Notification + struct Notification { typedef std::function OnNext; typedef std::function OnCompleted; @@ -804,11 +812,11 @@ namespace rxcpp TupleDispatch(Target target) : target(std::move(target)) { } template - auto operator()(const Tuple& tuple) + auto operator()(const Tuple& tuple) -> decltype(util::tuple_dispatch(target, tuple)) { return util::tuple_dispatch(target, tuple);} template - auto operator()(const Tuple& tuple) const + auto operator()(const Tuple& tuple) const -> decltype(util::tuple_dispatch(target, tuple)) { return util::tuple_dispatch(target, tuple);} }; @@ -818,13 +826,13 @@ namespace rxcpp return TupleDispatch(std::forward(target));} template - auto DispatchTuple(Tuple&& tuple, Target&& target) -> + auto DispatchTuple(Tuple&& tuple, Target&& target) -> decltype(util::tuple_dispatch(std::forward(target), std::forward(tuple))) { return util::tuple_dispatch(std::forward(target), std::forward(tuple));} #if RXCPP_USE_VARIADIC_TEMPLATES template - auto TieTuple(T&& t) -> + auto TieTuple(T&& t) -> decltype(util::tuple_tie(std::forward(t))) { return util::tuple_tie(std::forward(t));} #endif //RXCPP_USE_VARIADIC_TEMPLATES @@ -988,7 +996,7 @@ namespace detail { std::shared_ptr> observable(const std::shared_ptr < AsyncSubject < T >> &s){ return std::static_pointer_cast < Observable < T >> (s); } template - typename subject_observable::type observable(const std::shared_ptr < ConnectableSubject < Source, Subject >> &s){ + typename subject_observable::type observable(const std::shared_ptr < ConnectableSubject < Source, Subject >> &s){ return std::static_pointer_cast < Observable < typename subject_item::type >> (s); } template -- GitLab From f1f22d1902fd300fca56504939fe78c0b387ff12 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 5 Dec 2013 18:20:32 -0800 Subject: [PATCH 153/782] Begin adding unittests! --- .gitignore | 2 +- Rx/CPP/test/operators/Publish.cpp | 111 +++++++++ Rx/CPP/test/operators/Where.cpp | 389 ++++++++++++++++++++++++++++++ Rx/CPP/test/test.cpp | 2 + projects/CMake/CMakeLists.txt | 20 +- 5 files changed, 522 insertions(+), 2 deletions(-) create mode 100644 Rx/CPP/test/operators/Publish.cpp create mode 100644 Rx/CPP/test/operators/Where.cpp create mode 100644 Rx/CPP/test/test.cpp diff --git a/.gitignore b/.gitignore index ca7abf5..7156fda 100644 --- a/.gitignore +++ b/.gitignore @@ -106,4 +106,4 @@ Desktop.ini ############ projects/* -!projects/CMake/CMakelists.txt +!projects/CMake/CMakeLists.txt diff --git a/Rx/CPP/test/operators/Publish.cpp b/Rx/CPP/test/operators/Publish.cpp new file mode 100644 index 0000000..26e6e5b --- /dev/null +++ b/Rx/CPP/test/operators/Publish.cpp @@ -0,0 +1,111 @@ +#include "cpprx/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("publish_last", "[publish_last][publish][multicast][operators]"){ + GIVEN("a test hot observable of longs"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(110, 7), + m::OnNext(220, 3), + m::OnNext(280, 4), + m::OnNext(290, 1), + m::OnNext(340, 8), + m::OnNext(360, 5), + m::OnNext(370, 6), + m::OnNext(390, 7), + m::OnNext(410, 13), + m::OnNext(430, 2), + m::OnNext(450, 9), + m::OnNext(520, 11), + m::OnNext(560, 20), + m::OnCompleted(600) + }; + return m::ToVector(messages); + }() + ); + + auto res = scheduler->CreateObserver(); + + rx::SerialDisposable subscription; + std::shared_ptr> ys; + + WHEN("subscribed and then connected"){ + + scheduler->ScheduleAbsolute(rx::TestScheduler::Created, + [&invoked, &ys, &xs](rx::Scheduler::shared) { + ys = rx::observable(rx::from(xs) + .publish_last()); + return rx::Disposable::Empty(); + }); + + scheduler->ScheduleAbsolute(rx::TestScheduler::Subscribed, [&subscription, &ys, &res](rx::Scheduler::shared) { + subscription.Set(ys->Subscribe(res)); + return rx::Disposable::Empty(); + }); + + scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&subscription](rx::Scheduler::shared) { + subscription.Dispose(); + return rx::Disposable::Empty(); + }); + + auto connection = std::make_shared(); + scheduler->ScheduleAbsolute(300, [connection, &ys](rx::Scheduler::shared) { + connection->Set(ys->Connect()); + return rx::Disposable::Empty(); + }); + scheduler->ScheduleAbsolute(400, [connection](rx::Scheduler::shared) { + connection->Dispose(); + return rx::Disposable::Empty(); + }); + + connection = std::make_shared(); + scheduler->ScheduleAbsolute(500, [connection, &ys](rx::Scheduler::shared) { + connection->Set(ys->Connect()); + return rx::Disposable::Empty(); + }); + scheduler->ScheduleAbsolute(550, [connection](rx::Scheduler::shared) { + connection->Dispose(); + return rx::Disposable::Empty(); + }); + + connection = std::make_shared(); + scheduler->ScheduleAbsolute(650, [connection, &ys](rx::Scheduler::shared) { + connection->Set(ys->Connect()); + return rx::Disposable::Empty(); + }); + scheduler->ScheduleAbsolute(800, [connection](rx::Scheduler::shared) { + connection->Dispose(); + return rx::Disposable::Empty(); + }); + + scheduler->Start(); + + THEN("the output is empty"){ + std::vector required; + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there were 3 subscription/unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(300, 400), + m::Subscribe(500, 550), + m::Subscribe(650, 800) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + diff --git a/Rx/CPP/test/operators/Where.cpp b/Rx/CPP/test/operators/Where.cpp new file mode 100644 index 0000000..36cee52 --- /dev/null +++ b/Rx/CPP/test/operators/Where.cpp @@ -0,0 +1,389 @@ +#include "cpprx/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +bool IsPrime(int x) +{ + if (x < 2) return false; + for (int i = 2; i <= x/2; ++i) + { + if (x % i == 0) + return false; + } + return true; +} + +SCENARIO("where stops on completion", "[where][filter][operators]"){ + GIVEN("a test hot observable of longs"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(110, 1), + m::OnNext(180, 2), + m::OnNext(230, 3), + m::OnNext(270, 4), + m::OnNext(340, 5), + m::OnNext(380, 6), + m::OnNext(390, 7), + m::OnNext(450, 8), + m::OnNext(470, 9), + m::OnNext(560, 10), + m::OnNext(580, 11), + m::OnCompleted(600), + m::OnNext(610, 12), + m::OnError(620, std::exception()), + m::OnCompleted(630) + }; + return m::ToVector(messages); + }() + ); + + WHEN("filtered to longs that are primes"){ + + auto res = scheduler->Start( + [xs, &invoked]() { + return rx::observable(rx::from(xs) + .where([&invoked](long x) { + invoked++; + return IsPrime(x); + })); + } + ); + + THEN("the output only contains primes"){ + m::RecordedT items[] = { + m::OnNext(230, 3), + m::OnNext(340, 5), + m::OnNext(390, 7), + m::OnNext(580, 11), + m::OnCompleted(600) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(200, 600) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until completed"){ + REQUIRE(9 == invoked); + } + } + } +} + +SCENARIO("where stops on disposal", "[where][filter][operators]"){ + GIVEN("a test hot observable of longs"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(110, 1), + m::OnNext(180, 2), + m::OnNext(230, 3), + m::OnNext(270, 4), + m::OnNext(340, 5), + m::OnNext(380, 6), + m::OnNext(390, 7), + m::OnNext(450, 8), + m::OnNext(470, 9), + m::OnNext(560, 10), + m::OnNext(580, 11), + m::OnCompleted(600) + }; + return m::ToVector(messages); + }() + ); + + WHEN("filtered to longs that are primes"){ + + auto res = scheduler->Start( + [xs, &invoked]() { + return rx::observable(rx::from(xs) + .where([&invoked](long x) { + invoked++; + return IsPrime(x); + })); + }, + 400 + ); + + THEN("the output only contains primes that arrived before disposal"){ + m::RecordedT items[] = { + m::OnNext(230, 3), + m::OnNext(340, 5), + m::OnNext(390, 7) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(200, 400) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(5 == invoked); + } + } + } +} + +SCENARIO("where stops on error", "[where][filter][operators]"){ + GIVEN("a test hot observable of longs"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + std::exception ex; + + auto xs = scheduler->CreateHotObservable( + [ex]() { + m::RecordedT messages[] = { + m::OnNext(110, 1), + m::OnNext(180, 2), + m::OnNext(230, 3), + m::OnNext(270, 4), + m::OnNext(340, 5), + m::OnNext(380, 6), + m::OnNext(390, 7), + m::OnNext(450, 8), + m::OnNext(470, 9), + m::OnNext(560, 10), + m::OnNext(580, 11), + m::OnError(600, ex), + m::OnNext(610, 12), + m::OnError(620, std::exception()), + m::OnCompleted(630) + }; + return m::ToVector(messages); + }() + ); + + WHEN("filtered to longs that are primes"){ + + auto res = scheduler->Start( + [xs, &invoked]() { + return rx::observable(rx::from(xs) + .where([&invoked](long x) { + invoked++; + return IsPrime(x); + })); + } + ); + + THEN("the output only contains primes"){ + m::RecordedT items[] = { + m::OnNext(230, 3), + m::OnNext(340, 5), + m::OnNext(390, 7), + m::OnNext(580, 11), + m::OnError(600, ex), + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(200, 600) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until error"){ + REQUIRE(9 == invoked); + } + } + } +} + +SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ + GIVEN("a test hot observable of longs"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + std::exception ex; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(110, 1), + m::OnNext(180, 2), + m::OnNext(230, 3), + m::OnNext(270, 4), + m::OnNext(340, 5), + m::OnNext(380, 6), + m::OnNext(390, 7), + m::OnNext(450, 8), + m::OnNext(470, 9), + m::OnNext(560, 10), + m::OnNext(580, 11), + m::OnCompleted(600), + m::OnNext(610, 12), + m::OnError(620, std::exception()), + m::OnCompleted(630) + }; + return m::ToVector(messages); + }() + ); + + WHEN("filtered to longs that are primes"){ + + auto res = scheduler->Start( + [ex, xs, &invoked]() { + return rx::observable(rx::from(xs) + .where([ex, &invoked](long x) { + invoked++; + if (x > 5) { + throw ex; + } + return IsPrime(x); + })); + } + ); + + THEN("the output only contains primes"){ + m::RecordedT items[] = { + m::OnNext(230, 3), + m::OnNext(340, 5), + m::OnError(380, ex) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(200, 380) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until error"){ + REQUIRE(4 == invoked); + } + } + } +} + +SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ + GIVEN("a test hot observable of longs"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(110, 1), + m::OnNext(180, 2), + m::OnNext(230, 3), + m::OnNext(270, 4), + m::OnNext(340, 5), + m::OnNext(380, 6), + m::OnNext(390, 7), + m::OnNext(450, 8), + m::OnNext(470, 9), + m::OnNext(560, 10), + m::OnNext(580, 11), + m::OnCompleted(600), + m::OnNext(610, 12), + m::OnError(620, std::exception()), + m::OnCompleted(630) + }; + return m::ToVector(messages); + }() + ); + + auto res = scheduler->CreateObserver(); + + rx::SerialDisposable d; + std::shared_ptr> ys; + + WHEN("filtered to longs that are primes"){ + + scheduler->ScheduleAbsolute(rx::TestScheduler::Created, + [&invoked, &d, &ys, &xs](rx::Scheduler::shared) { + ys = rx::observable(rx::from(xs) + .where([&invoked, &d](long x) { + invoked++; + if (x == 8) + d.Dispose(); + return IsPrime(x); + })); + return rx::Disposable::Empty(); + }); + + scheduler->ScheduleAbsolute(rx::TestScheduler::Subscribed, [&d, &ys, &res](rx::Scheduler::shared) { + d.Set(ys->Subscribe(res)); + return rx::Disposable::Empty(); + }); + + scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&d](rx::Scheduler::shared) { + d.Dispose(); + return rx::Disposable::Empty(); + }); + + scheduler->Start(); + + THEN("the output only contains primes"){ + m::RecordedT items[] = { + m::OnNext(230, 3), + m::OnNext(340, 5), + m::OnNext(390, 7) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(200, 450) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(6 == invoked); + } + } + } +} + diff --git a/Rx/CPP/test/test.cpp b/Rx/CPP/test/test.cpp new file mode 100644 index 0000000..0c7c351 --- /dev/null +++ b/Rx/CPP/test/test.cpp @@ -0,0 +1,2 @@ +#define CATCH_CONFIG_MAIN +#include "catch.hpp" diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 866beec..4080292 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -17,10 +17,28 @@ get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) set(TEST_DIR ${RXCPP_DIR}/Rx/CPP/test) -include_directories(${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/CPP/src) +include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/CPP/src) + +# define the sources of the self test +set(TEST_SOURCES + ${TEST_DIR}/test.cpp + ${TEST_DIR}/operators/Publish.cpp + ${TEST_DIR}/operators/Where.cpp +) +add_executable(rxcpp_test ${TEST_SOURCES}) # define the sources of testbench set(TESTBENCH_SOURCES ${RXCPP_DIR}/Rx/CPP/testbench/testbench.cpp ) add_executable(testbench ${TESTBENCH_SOURCES}) + +# configure unit tests via CTest +enable_testing() +add_test(NAME RunTests COMMAND rxcpp_test) + +add_test(NAME ListTests COMMAND rxcpp_test --list-tests) +set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases") + +add_test(NAME ListTags COMMAND rxcpp_test --list-tags) +set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags") -- GitLab From ad5e1f1ac8c50bafe19dad0d8faa8e2d8b729cf9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Dec 2013 09:36:43 -0800 Subject: [PATCH 154/782] add nuget package description Conflicts: .gitignore --- .gitignore | 1 + projects/nuget/rxcpp.autoconfig | 31 +++++++++++++++++++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 projects/nuget/rxcpp.autoconfig diff --git a/.gitignore b/.gitignore index 7156fda..6fe9162 100644 --- a/.gitignore +++ b/.gitignore @@ -107,3 +107,4 @@ Desktop.ini projects/* !projects/CMake/CMakeLists.txt +!projects/nuget/rxcpp.autopackage diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig new file mode 100644 index 0000000..640c1c9 --- /dev/null +++ b/projects/nuget/rxcpp.autoconfig @@ -0,0 +1,31 @@ +nuget { + nuspec { + id = rxcpp; + version : 2.2.1.0; + title: Reactive Extensions for C++; + authors: {Microsoft Open Technologies Inc.}; + owners: {Microsoft Open Technologies Inc.}; + licenseUrl: "http://rxcpp.codeplex.com/license"; + projectUrl: "https://rxcpp.codeplex.com/"; + iconUrl: "http://download-codeplex.sec.s-msft.com/Download?ProjectName=rx&DownloadId=604538&Build=20828"; + requireLicenseAcceptance:false; + summary: "The Reactive Extensions (Rx) asynchronous programming library"; + description: @"The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and operators. Operators are the asynchronous form of standard library algorithms and they operate on Observables instead of iterators. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize the concurrency in the asynchronous data streams using Schedulers."; + releaseNotes: "This release has many new operators and schedulers. Also some preliminary ssupprot for MVVM in WinRT."; + copyright: Copyright 2013; + tags: { RXCPP, RXC++, RX, native, MSOpenTech}; + }; + + files { + + #defines { + SDK_RX = ..\..\; + } + include: { "${SDK_RX}Rx\CPP\src\**\*", "${SDK_RX}Ix\CPP\src\**\*" }; + docs: { ${SDK_RX}Readme.html }; + } + + targets { + Defines += HAS_RXCPP; + } +} -- GitLab From 8318bd7a707214df241dba2b0554a9d908b5901c Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 11 Dec 2013 07:43:03 -0800 Subject: [PATCH 155/782] add license.txt and authors.txt to nuget package --- projects/nuget/rxcpp.autoconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig index 640c1c9..cdd6602 100644 --- a/projects/nuget/rxcpp.autoconfig +++ b/projects/nuget/rxcpp.autoconfig @@ -22,7 +22,7 @@ nuget { SDK_RX = ..\..\; } include: { "${SDK_RX}Rx\CPP\src\**\*", "${SDK_RX}Ix\CPP\src\**\*" }; - docs: { ${SDK_RX}Readme.html }; + docs: { ${SDK_RX}Readme.html, ${SDK_RX}AUTHORS.txt, ${SDK_RX}Rx\CPP\license.txt }; } targets { -- GitLab From c3325e3499d56a79b292785a5e12da6fda030ea6 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 11 Dec 2013 07:57:55 -0800 Subject: [PATCH 156/782] add dependency on the Catch unittest library --- .gitmodules | 3 +++ ext/catch | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 ext/catch diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..2dcede7 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "ext/catch"] + path = ext/catch + url = https://github.com/philsquared/Catch.git diff --git a/ext/catch b/ext/catch new file mode 160000 index 0000000..8ba6555 --- /dev/null +++ b/ext/catch @@ -0,0 +1 @@ +Subproject commit 8ba6555acd25da27cc9d8210119c0c57edac4704 -- GitLab From a76c632e517844c2083c85f29efb77040c2a5520 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 11 Dec 2013 08:52:35 -0800 Subject: [PATCH 157/782] Added Return tests --- Rx/CPP/test/operators/Return.cpp | 119 +++++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 120 insertions(+) create mode 100644 Rx/CPP/test/operators/Return.cpp diff --git a/Rx/CPP/test/operators/Return.cpp b/Rx/CPP/test/operators/Return.cpp new file mode 100644 index 0000000..44c38cf --- /dev/null +++ b/Rx/CPP/test/operators/Return.cpp @@ -0,0 +1,119 @@ +#include "cpprx/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("return basic", "[return][operators]"){ + GIVEN("return 42"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + auto res = scheduler->Start( + [=]() { + return rx::Return(42, scheduler); + } + ); + + WHEN("started"){ + + THEN("the output is 42"){ + m::RecordedT items[] = { + m::OnNext(201, 42), + m::OnCompleted(201) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("return disposed", "[return][operators]"){ + GIVEN("test scheduler"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + WHEN("return 42 after disposed"){ + auto res = scheduler->Start( + [&]() { + return rx::Return(42, scheduler); + }, + 200 + ); + + THEN("the output is empty"){ + std::vector required; + auto actual = res->Messages(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("return disposed after next", "[return][operators]"){ + GIVEN("return 42 after disposal"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + rx::SerialDisposable d; + + auto xs = rx::Return(42, scheduler); + + auto res = scheduler->CreateObserver(); + + scheduler->ScheduleAbsolute( + 100, + [&](rx::Scheduler::shared) { + d.Set(from(xs).subscribe( + [&](int x){ + d.Dispose(); res->OnNext(x);}, + [&](){ + res->OnCompleted();}, + [&](std::exception_ptr ex){ + res->OnError(ex);})); + return d; + } + ); + + WHEN("started"){ + + scheduler->Start(); + + THEN("the output is 42"){ + m::RecordedT items[] = { + m::OnNext(101, 42) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("return observer throws", "[return][operators]"){ + GIVEN("return 42"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + auto xs = rx::Return(42, scheduler); + + WHEN("subscribed to onnext that throws"){ + from(xs).subscribe([](int){ throw std::runtime_error("onnext throws"); }); + + THEN("the exception is not supressed"){ + REQUIRE_THROWS(scheduler->Start()); + } + } + + WHEN("subscribed to oncompleted that throws"){ + from(xs).subscribe([](int){},[](){ throw std::runtime_error("oncompleted throws"); }); + + THEN("the exception is not supressed"){ + REQUIRE_THROWS(scheduler->Start()); + } + } + } +} + diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 4080292..c3afa34 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -22,6 +22,7 @@ include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXC # define the sources of the self test set(TEST_SOURCES ${TEST_DIR}/test.cpp + ${TEST_DIR}/operators/Return.cpp ${TEST_DIR}/operators/Publish.cpp ${TEST_DIR}/operators/Where.cpp ) -- GitLab From 3610224d8e1aacb346cdd967ceaa95cb3d622456 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 06:48:19 -0800 Subject: [PATCH 158/782] add editor config, install plugin for your editor to use it. --- .editorconfig | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 .editorconfig diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..8ac3f31 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,9 @@ +root = true + +[*] +indent_style = space +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true -- GitLab From dd18b7e7bff4866fcef1f56a3b0f56ae550f5643 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 09:51:00 -0800 Subject: [PATCH 159/782] enable Throw operator to take any type and make a std::exception_ptr --- Rx/CPP/src/cpprx/operators/Throw.hpp | 35 ++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 5 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Throw.hpp b/Rx/CPP/src/cpprx/operators/Throw.hpp index 13530d3..1d39351 100644 --- a/Rx/CPP/src/cpprx/operators/Throw.hpp +++ b/Rx/CPP/src/cpprx/operators/Throw.hpp @@ -65,15 +65,40 @@ namespace rxcpp } } }; + + struct throw_ptr_tag{}; + struct throw_instance_tag{}; + + template + std::shared_ptr> Throw( + throw_ptr_tag&&, + std::exception_ptr exception, + Scheduler::shared scheduler = nullptr + ) + { + return std::make_shared>(std::move(exception), std::move(scheduler)); + } + + template + std::shared_ptr> Throw( + throw_instance_tag&&, + E e, + Scheduler::shared scheduler = nullptr + ) + { + std::exception_ptr exception; + try {throw e;} catch(...) {exception = std::current_exception();} + return std::make_shared>(std::move(exception), std::move(scheduler)); + } } - template - const std::shared_ptr> Throw( - std::exception_ptr exception, + template + std::shared_ptr> Throw( + E e, Scheduler::shared scheduler = nullptr ) { - return std::make_shared>(std::move(exception), std::move(scheduler)); + return detail::Throw(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::forward(e), std::move(scheduler)); } } -#endif \ No newline at end of file +#endif -- GitLab From eff65b25d387922d2b57c8e5b0ae173f703b0d31 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 09:51:31 -0800 Subject: [PATCH 160/782] switch from longs to ints --- Rx/CPP/test/operators/Where.cpp | 74 ++++++++++++++++----------------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/Rx/CPP/test/operators/Where.cpp b/Rx/CPP/test/operators/Where.cpp index 36cee52..ddfbb3a 100644 --- a/Rx/CPP/test/operators/Where.cpp +++ b/Rx/CPP/test/operators/Where.cpp @@ -8,21 +8,21 @@ bool IsPrime(int x) if (x < 2) return false; for (int i = 2; i <= x/2; ++i) { - if (x % i == 0) + if (x % i == 0) return false; } return true; } SCENARIO("where stops on completion", "[where][filter][operators]"){ - GIVEN("a test hot observable of longs"){ + GIVEN("a test hot observable of ints"){ auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages m; long invoked = 0; auto xs = scheduler->CreateHotObservable( - []() { + []() { m::RecordedT messages[] = { m::OnNext(110, 1), m::OnNext(180, 2), @@ -44,12 +44,12 @@ SCENARIO("where stops on completion", "[where][filter][operators]"){ }() ); - WHEN("filtered to longs that are primes"){ + WHEN("filtered to ints that are primes"){ - auto res = scheduler->Start( + auto res = scheduler->Start( [xs, &invoked]() { return rx::observable(rx::from(xs) - .where([&invoked](long x) { + .where([&invoked](int x) { invoked++; return IsPrime(x); })); @@ -86,14 +86,14 @@ SCENARIO("where stops on completion", "[where][filter][operators]"){ } SCENARIO("where stops on disposal", "[where][filter][operators]"){ - GIVEN("a test hot observable of longs"){ + GIVEN("a test hot observable of ints"){ auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages m; long invoked = 0; auto xs = scheduler->CreateHotObservable( - []() { + []() { m::RecordedT messages[] = { m::OnNext(110, 1), m::OnNext(180, 2), @@ -112,12 +112,12 @@ SCENARIO("where stops on disposal", "[where][filter][operators]"){ }() ); - WHEN("filtered to longs that are primes"){ + WHEN("filtered to ints that are primes"){ - auto res = scheduler->Start( + auto res = scheduler->Start( [xs, &invoked]() { return rx::observable(rx::from(xs) - .where([&invoked](long x) { + .where([&invoked](int x) { invoked++; return IsPrime(x); })); @@ -153,16 +153,16 @@ SCENARIO("where stops on disposal", "[where][filter][operators]"){ } SCENARIO("where stops on error", "[where][filter][operators]"){ - GIVEN("a test hot observable of longs"){ + GIVEN("a test hot observable of ints"){ auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages m; long invoked = 0; std::exception ex; auto xs = scheduler->CreateHotObservable( - [ex]() { + [ex]() { m::RecordedT messages[] = { m::OnNext(110, 1), m::OnNext(180, 2), @@ -184,12 +184,12 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ }() ); - WHEN("filtered to longs that are primes"){ + WHEN("filtered to ints that are primes"){ - auto res = scheduler->Start( + auto res = scheduler->Start( [xs, &invoked]() { return rx::observable(rx::from(xs) - .where([&invoked](long x) { + .where([&invoked](int x) { invoked++; return IsPrime(x); })); @@ -226,16 +226,16 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ } SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ - GIVEN("a test hot observable of longs"){ + GIVEN("a test hot observable of ints"){ auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages m; long invoked = 0; std::exception ex; auto xs = scheduler->CreateHotObservable( - []() { + []() { m::RecordedT messages[] = { m::OnNext(110, 1), m::OnNext(180, 2), @@ -257,12 +257,12 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ }() ); - WHEN("filtered to longs that are primes"){ + WHEN("filtered to ints that are primes"){ - auto res = scheduler->Start( + auto res = scheduler->Start( [ex, xs, &invoked]() { return rx::observable(rx::from(xs) - .where([ex, &invoked](long x) { + .where([ex, &invoked](int x) { invoked++; if (x > 5) { throw ex; @@ -300,14 +300,14 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ } SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ - GIVEN("a test hot observable of longs"){ + GIVEN("a test hot observable of ints"){ auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages m; long invoked = 0; auto xs = scheduler->CreateHotObservable( - []() { + []() { m::RecordedT messages[] = { m::OnNext(110, 1), m::OnNext(180, 2), @@ -329,17 +329,17 @@ SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ }() ); - auto res = scheduler->CreateObserver(); + auto res = scheduler->CreateObserver(); rx::SerialDisposable d; - std::shared_ptr> ys; + std::shared_ptr> ys; - WHEN("filtered to longs that are primes"){ + WHEN("filtered to ints that are primes"){ - scheduler->ScheduleAbsolute(rx::TestScheduler::Created, - [&invoked, &d, &ys, &xs](rx::Scheduler::shared) { + scheduler->ScheduleAbsolute(rx::TestScheduler::Created, + [&invoked, &d, &ys, &xs](rx::Scheduler::shared) { ys = rx::observable(rx::from(xs) - .where([&invoked, &d](long x) { + .where([&invoked, &d](int x) { invoked++; if (x == 8) d.Dispose(); @@ -348,13 +348,13 @@ SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ return rx::Disposable::Empty(); }); - scheduler->ScheduleAbsolute(rx::TestScheduler::Subscribed, [&d, &ys, &res](rx::Scheduler::shared) { + scheduler->ScheduleAbsolute(rx::TestScheduler::Subscribed, [&d, &ys, &res](rx::Scheduler::shared) { d.Set(ys->Subscribe(res)); return rx::Disposable::Empty(); }); - scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&d](rx::Scheduler::shared) { - d.Dispose(); + scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&d](rx::Scheduler::shared) { + d.Dispose(); return rx::Disposable::Empty(); }); -- GitLab From 071fed3aa211a33acdfc607ebd90678bd72c4843 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 09:52:07 -0800 Subject: [PATCH 161/782] Duplicate some more logic for exception handling --- Rx/CPP/src/cpprx/rx-operators.hpp | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp index a216573..cbef605 100644 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ b/Rx/CPP/src/cpprx/rx-operators.hpp @@ -75,6 +75,19 @@ namespace rxcpp local->Dispose(); }); } + + bool Fail(const std::exception_ptr& error) + { + if (!isStopped.exchange(true)) { + auto keepAlive = this->shared_from_this(); + RXCPP_UNWIND(disposer, [&](){ + this->disposable.Dispose(); + }); + observer->OnError(error); + return true; + } + return false; + } }; template @@ -109,7 +122,9 @@ namespace rxcpp try { autoDetachObserver->disposable.Set(this->subscribe(autoDetachObserver)); } catch (...) { - autoDetachObserver->OnError(std::current_exception()); + if (!autoDetachObserver->Fail(std::current_exception())) { + throw; + } } return Disposable::Empty(); } @@ -120,7 +135,9 @@ namespace rxcpp autoDetachObserver->disposable.Set(subscribe(autoDetachObserver)); return *autoDetachObserver; } catch (...) { - autoDetachObserver->OnError(std::current_exception()); + if (!autoDetachObserver->Fail(std::current_exception())) { + throw; + } } return *autoDetachObserver; } -- GitLab From f3b2be75c9fa878ebc2081a867707b17d27321e7 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 09:52:35 -0800 Subject: [PATCH 162/782] reimplement the select operator --- Rx/CPP/src/cpprx/operators/Select.hpp | 107 +++++++++++++++++--------- 1 file changed, 72 insertions(+), 35 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Select.hpp b/Rx/CPP/src/cpprx/operators/Select.hpp index 42d40be..608d911 100644 --- a/Rx/CPP/src/cpprx/operators/Select.hpp +++ b/Rx/CPP/src/cpprx/operators/Select.hpp @@ -9,44 +9,81 @@ namespace rxcpp { - template + namespace detail + { + template + class SelectObservable : public Producer, Tout> + { + typedef SelectObservable Self; + typedef std::shared_ptr Parent; + typedef std::function Selector; + + std::shared_ptr> source; + Selector selector; + + class _ : public Sink<_, Tout>, public Observer + { + Parent parent; + + public: + typedef Sink<_, Tout> SinkBase; + + _(Parent parent, std::shared_ptr < Observer < Tout >> observer, Disposable cancel) : + SinkBase(std::move(observer), std::move(cancel)), + parent(parent) + { + } + + virtual void OnNext(const Tin& t) + { + util::maybe result; + try { + result.set(parent->selector(t)); + } catch (...) { + SinkBase::observer->OnError(std::current_exception()); + SinkBase::Dispose(); + } + if (!!result) { + SinkBase::observer->OnNext(*result.get()); + } + } + virtual void OnCompleted() + { + SinkBase::observer->OnCompleted(); + SinkBase::Dispose(); + } + virtual void OnError(const std::exception_ptr& e) + { + SinkBase::observer->OnError(e); + SinkBase::Dispose(); + } + }; + + typedef Producer ProducerBase; + public: + + SelectObservable(const std::shared_ptr>& source, Selector selector) : + ProducerBase([this](Parent parent, std::shared_ptr < Observer < Tout >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable + { + auto sink = std::shared_ptr(new Self::_(parent, observer, std::move(cancel))); + setSink(sink->GetDisposable()); + return this->source->Subscribe(sink); + }), + source(source), + selector(std::move(selector)) + { + } + }; + } + template auto Select( - const std::shared_ptr>& source, + const std::shared_ptr>& source, S selector - ) - -> const std::shared_ptr::type>> + ) -> const std::shared_ptr::type>> { - typedef typename std::result_of::type U; - return CreateObservable( - [=](std::shared_ptr> observer) - { - return Subscribe( - source, - // on next - [=](const T& element) - { - util::maybe result; - try { - result.set(selector(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); + typedef typename std::result_of::type Tout; + return std::make_shared>(source, std::move(selector)); } } -#endif \ No newline at end of file +#endif -- GitLab From 0f61f3bc202e6854d8daefabc0ba74752ed0f8ae Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 12 Dec 2013 09:52:59 -0800 Subject: [PATCH 163/782] add Select unittests --- Rx/CPP/test/operators/Select.cpp | 181 +++++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 3 +- 2 files changed, 183 insertions(+), 1 deletion(-) create mode 100644 Rx/CPP/test/operators/Select.cpp diff --git a/Rx/CPP/test/operators/Select.cpp b/Rx/CPP/test/operators/Select.cpp new file mode 100644 index 0000000..2de7f21 --- /dev/null +++ b/Rx/CPP/test/operators/Select.cpp @@ -0,0 +1,181 @@ +#include "cpprx/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("select throws", "[select][map][operators]"){ + GIVEN("select"){ + WHEN("subscribed to onnext that throws"){ + THEN("the exception is not supressed"){ + auto next_throws = [](int){ + throw std::runtime_error("onnext throws"); }; + REQUIRE_THROWS(from(rx::Return(1)) + .select([](int v){return v;}) + .subscribe(next_throws)); + } + } + + WHEN("subscribed to throw operator"){ + THEN("the exception is not supressed"){ + REQUIRE_THROWS(from(rx::Throw(std::runtime_error("throw operator"))) + .select([](int v){return v;}) + .subscribe([](int){}, [](){}, [](std::exception_ptr){ throw std::runtime_error("onerror throws"); })); + } + } + + WHEN("subscribed to oncompleted that throws"){ + THEN("the exception is not supressed"){ + REQUIRE_THROWS(from(rx::Empty()) + .select([](int v){return v;}) + .subscribe([](int){}, [](){ throw std::runtime_error("oncompleted throws"); }, [](std::exception_ptr){})); + } + } + } +} + +SCENARIO("select should throw", "[select][map][operators][hide]"){ + GIVEN("select"){ + WHEN("subscribe throws"){ + THEN("the exception is not supressed"){ + // not yet sure why this fails + auto subscribe_throws = [](std::shared_ptr> observer) -> rxcpp::Disposable { + throw std::runtime_error("subscribe throws"); }; + REQUIRE_THROWS(from(rx::CreateObservable(subscribe_throws)) + .select([](int v){return v;}) + .subscribe([](int){})); + } + } + } +} + +SCENARIO("select stops on completion", "[select][map][operators]"){ + GIVEN("a test hot observable of ints"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(180, 1), + m::OnNext(210, 2), + m::OnNext(240, 3), + m::OnNext(290, 4), + m::OnNext(350, 5), + m::OnCompleted(400), + m::OnNext(410, -1), + m::OnCompleted(420), + m::OnError(430, std::exception()) + }; + return m::ToVector(messages); + }() + ); + + WHEN("mapped to ints that are one larger"){ + + auto res = scheduler->Start( + [xs, &invoked]() { + return rx::observable(rx::from(xs) + .select([&invoked](int x) { + invoked++; + return x + 1; + })); + } + ); + + THEN("the output only contains primes"){ + m::RecordedT items[] = { + m::OnNext(210, 3), + m::OnNext(240, 4), + m::OnNext(290, 5), + m::OnNext(350, 6), + m::OnCompleted(400), + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(200, 400) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until completed"){ + REQUIRE(4 == invoked); + } + } + } +} + +SCENARIO("select stops on disposal", "[select][map][operators]"){ + GIVEN("a test hot observable of ints"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + long invoked = 0; + + auto xs = scheduler->CreateHotObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(100, 1), + m::OnNext(200, 2), + m::OnNext(500, 3), + m::OnNext(600, 4) + }; + return m::ToVector(messages); + }() + ); + + auto res = scheduler->CreateObserver(); + + WHEN("the ints are identity mapped"){ + + rx::SerialDisposable d; + + d.Set(observable(from(xs) + .select([&](int x) { + invoked++; + if (scheduler->Clock() > 400) { + d.Dispose(); + } + return x; + })) + ->Subscribe(observer(res)) + ); + + scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&](rx::Scheduler::shared) { + d.Dispose(); return rx::Disposable::Empty();}); + + scheduler->Start(); + + THEN("the output only contains values that arrived before disposal"){ + m::RecordedT items[] = { + m::OnNext(100, 1), + m::OnNext(200, 2) + }; + auto required = m::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rx::Subscription items[] = { + m::Subscribe(0, 500) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("select was called until disposed"){ + REQUIRE(3 == invoked); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index c3afa34..bf85ff3 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -23,8 +23,9 @@ include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXC set(TEST_SOURCES ${TEST_DIR}/test.cpp ${TEST_DIR}/operators/Return.cpp - ${TEST_DIR}/operators/Publish.cpp + ${TEST_DIR}/operators/Select.cpp ${TEST_DIR}/operators/Where.cpp + ${TEST_DIR}/operators/Publish.cpp ) add_executable(rxcpp_test ${TEST_SOURCES}) -- GitLab From b62cd524c35deb0158c0ab979e84102c097a862b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 13 Dec 2013 21:56:31 -0800 Subject: [PATCH 164/782] update nuget settings --- projects/nuget/rxcpp.autoconfig | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig index cdd6602..b354d6c 100644 --- a/projects/nuget/rxcpp.autoconfig +++ b/projects/nuget/rxcpp.autoconfig @@ -1,19 +1,19 @@ nuget { nuspec { id = rxcpp; - version : 2.2.1.0; + version : 1.0.0; title: Reactive Extensions for C++; authors: {Microsoft Open Technologies Inc.}; owners: {Microsoft Open Technologies Inc.}; licenseUrl: "http://rxcpp.codeplex.com/license"; projectUrl: "https://rxcpp.codeplex.com/"; - iconUrl: "http://download-codeplex.sec.s-msft.com/Download?ProjectName=rx&DownloadId=604538&Build=20828"; + iconUrl: "http://go.microsoft.com/fwlink/?LinkId=261274"; requireLicenseAcceptance:false; summary: "The Reactive Extensions (Rx) asynchronous programming library"; description: @"The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and operators. Operators are the asynchronous form of standard library algorithms and they operate on Observables instead of iterators. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize the concurrency in the asynchronous data streams using Schedulers."; - releaseNotes: "This release has many new operators and schedulers. Also some preliminary ssupprot for MVVM in WinRT."; + releaseNotes: "This release has many new operators and schedulers. Also some preliminary support for MVVM in WinRT."; copyright: Copyright 2013; - tags: { RXCPP, RXC++, RX, native, MSOpenTech}; + tags: { RxCpp, RxC++, Rx, Reactive, Observable, Functional, native}; }; files { @@ -24,7 +24,7 @@ nuget { include: { "${SDK_RX}Rx\CPP\src\**\*", "${SDK_RX}Ix\CPP\src\**\*" }; docs: { ${SDK_RX}Readme.html, ${SDK_RX}AUTHORS.txt, ${SDK_RX}Rx\CPP\license.txt }; } - + targets { Defines += HAS_RXCPP; } -- GitLab From 5969b968e5251cd5a3b631dbcd8488d00c1140a8 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 13 Dec 2013 22:03:00 -0800 Subject: [PATCH 165/782] remove name hiding from Throw --- Rx/CPP/src/cpprx/operators/Throw.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Throw.hpp b/Rx/CPP/src/cpprx/operators/Throw.hpp index 1d39351..425f5eb 100644 --- a/Rx/CPP/src/cpprx/operators/Throw.hpp +++ b/Rx/CPP/src/cpprx/operators/Throw.hpp @@ -70,7 +70,7 @@ namespace rxcpp struct throw_instance_tag{}; template - std::shared_ptr> Throw( + std::shared_ptr> make_throw( throw_ptr_tag&&, std::exception_ptr exception, Scheduler::shared scheduler = nullptr @@ -80,7 +80,7 @@ namespace rxcpp } template - std::shared_ptr> Throw( + std::shared_ptr> make_throw( throw_instance_tag&&, E e, Scheduler::shared scheduler = nullptr @@ -97,7 +97,7 @@ namespace rxcpp Scheduler::shared scheduler = nullptr ) { - return detail::Throw(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::forward(e), std::move(scheduler)); + return detail::make_throw(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::forward(e), std::move(scheduler)); } } -- GitLab From ca88bc80c5f8ab7d6fd29a9af2eb3fd0d12c5ed2 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Mon, 16 Dec 2013 20:45:38 -0800 Subject: [PATCH 166/782] fixes SelectMany disposal --- Rx/CPP/src/cpprx/operators/SelectMany.hpp | 156 ++++++++-------------- 1 file changed, 59 insertions(+), 97 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/SelectMany.hpp b/Rx/CPP/src/cpprx/operators/SelectMany.hpp index b24cb20..e282ced 100644 --- a/Rx/CPP/src/cpprx/operators/SelectMany.hpp +++ b/Rx/CPP/src/cpprx/operators/SelectMany.hpp @@ -28,129 +28,91 @@ namespace rxcpp -> Disposable { struct State { - size_t subscribed; - bool cancel; + std::atomic count; std::mutex lock; + ComposableDisposable group; }; auto state = std::make_shared(); - state->cancel = false; - state->subscribed = 0; + state->count = 0; - ComposableDisposable cd; + SerialDisposable sourceDisposable; + state->group.Add(sourceDisposable); - cd.Add(Disposable([=]{ - std::unique_lock guard(state->lock); - state->cancel = true; }) - ); - - ++state->subscribed; - cd.Add(Subscribe( + ++state->count; + sourceDisposable.Set(Subscribe( source, // on next [=](const T& sourceElement) { - bool cancel = false; - { + util::maybe collection; + try { + collection.set(collectionSelector(sourceElement)); + } catch(...) { std::unique_lock guard(state->lock); - cancel = state->cancel; - if (!cancel) ++state->subscribed; + observer->OnError(std::current_exception()); + state->group.Dispose(); + return; } - if (!cancel) { - util::maybe collection; - try { - collection.set(collectionSelector(sourceElement)); - } catch(...) { - bool cancel = false; - { + + SerialDisposable inner; + state->group.Add(inner); + + ++state->count; + inner.Set(Subscribe( + *collection.get(), + // on next + [=](const CI& collectionElement) + { + util::maybe result; + try { + result.set(resultSelector(sourceElement, collectionElement)); + } catch(...) { std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { observer->OnError(std::current_exception()); + state->group.Dispose(); } - cd.Dispose(); - } - if (!!collection) { - cd.Add(Subscribe( - *collection.get(), - // on next - [=](const CI& collectionElement) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - util::maybe result; - try { - result.set(resultSelector(sourceElement, collectionElement)); - } catch(...) { - observer->OnError(std::current_exception()); - cd.Dispose(); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - { - std::unique_lock guard(state->lock); - finished = (--state->subscribed) == 0; - cancel = state->cancel; - } - if (!cancel && finished) - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - --state->subscribed; - cancel = state->cancel; - } - if (!cancel) - observer->OnError(error); - cd.Dispose(); - })); - } - } + std::unique_lock guard(state->lock); + observer->OnNext(std::move(*result.get())); + }, + // on completed + [=] + { + inner.Dispose(); + if (0 == --state->count) { + std::unique_lock guard(state->lock); + observer->OnCompleted(); + state->group.Dispose(); + } + }, + // on error + [=](const std::exception_ptr& error) + { + std::unique_lock guard(state->lock); + observer->OnError(error); + state->group.Dispose(); + })); }, // on completed [=] { - bool cancel = false; - bool finished = false; - { + if (0 == --state->count) { std::unique_lock guard(state->lock); - finished = (--state->subscribed) == 0; - cancel = state->cancel; + observer->OnCompleted(); + state->group.Dispose(); + } else { + sourceDisposable.Dispose(); } - if (!cancel && finished) - observer->OnCompleted(); }, // on error [=](const std::exception_ptr& error) { - bool cancel = false; - { - std::unique_lock guard(state->lock); - --state->subscribed; - cancel = state->cancel; - } - if (!cancel) - observer->OnError(error); + std::unique_lock guard(state->lock); + observer->OnError(error); + state->group.Dispose(); })); - return cd; + return state->group; }); } } -#endif \ No newline at end of file +#endif -- GitLab From 7285302bea92b80e03e03d59ae4d6e9a45953e2b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Mon, 16 Dec 2013 20:47:37 -0800 Subject: [PATCH 167/782] adds SelectMany unittests --- Rx/CPP/test/operators/SelectMany.cpp | 96 ++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 97 insertions(+) create mode 100644 Rx/CPP/test/operators/SelectMany.cpp diff --git a/Rx/CPP/test/operators/SelectMany.cpp b/Rx/CPP/test/operators/SelectMany.cpp new file mode 100644 index 0000000..bfd5cbf --- /dev/null +++ b/Rx/CPP/test/operators/SelectMany.cpp @@ -0,0 +1,96 @@ +#include "cpprx/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("select_many", "[select_many][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages ms; + + long invoked = 0; + + auto xs = scheduler->CreateColdObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(100, 4), + m::OnNext(200, 2), + m::OnNext(300, 3), + m::OnNext(400, 1), + m::OnCompleted(500) + }; + return m::ToVector(messages); + }() + ); + + auto ys = scheduler->CreateColdObservable( + []() { + ms::RecordedT messages[] = { + ms::OnNext(50, "foo"), + ms::OnNext(100, "bar"), + ms::OnNext(150, "baz"), + ms::OnNext(200, "qux"), + ms::OnCompleted(250) + }; + return ms::ToVector(messages); + }() + ); + + WHEN("each int is mapped to the strings"){ + + auto res = scheduler->Start( + [&]() { + return observable(from(xs) + .select_many([&](int){return ys;})); + } + ); + + THEN("the output contains strings repeated for each int"){ + ms::RecordedT items[] = { + ms::OnNext(350, "foo"), + ms::OnNext(400, "bar"), + ms::OnNext(450, "foo"), + ms::OnNext(450, "baz"), + ms::OnNext(500, "bar"), + ms::OnNext(500, "qux"), + ms::OnNext(550, "baz"), + ms::OnNext(550, "foo"), + ms::OnNext(600, "bar"), + ms::OnNext(600, "qux"), + ms::OnNext(650, "baz"), + ms::OnNext(650, "foo"), + ms::OnNext(700, "qux"), + ms::OnNext(700, "bar"), + ms::OnNext(750, "baz"), + ms::OnNext(800, "qux"), + ms::OnCompleted(850) + }; + auto required = ms::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + rx::Subscription items[] = { + m::Subscribe(200, 700) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + rx::Subscription items[] = { + ms::Subscribe(300, 550), + ms::Subscribe(400, 650), + ms::Subscribe(500, 750), + ms::Subscribe(600, 850) + }; + auto required = m::ToVector(items); + auto actual = ys->Subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index bf85ff3..3933df6 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -24,6 +24,7 @@ set(TEST_SOURCES ${TEST_DIR}/test.cpp ${TEST_DIR}/operators/Return.cpp ${TEST_DIR}/operators/Select.cpp + ${TEST_DIR}/operators/SelectMany.cpp ${TEST_DIR}/operators/Where.cpp ${TEST_DIR}/operators/Publish.cpp ) -- GitLab From 9d74d6504fdc90ee6a1e1b99b5ae4e4e337ea7d1 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Mon, 16 Dec 2013 21:42:28 -0800 Subject: [PATCH 168/782] more SelectMany unittests --- Rx/CPP/test/operators/SelectMany.cpp | 185 ++++++++++++++++++++++++++- 1 file changed, 184 insertions(+), 1 deletion(-) diff --git a/Rx/CPP/test/operators/SelectMany.cpp b/Rx/CPP/test/operators/SelectMany.cpp index bfd5cbf..9ab6602 100644 --- a/Rx/CPP/test/operators/SelectMany.cpp +++ b/Rx/CPP/test/operators/SelectMany.cpp @@ -3,7 +3,7 @@ namespace rx=rxcpp; #include "catch.hpp" -SCENARIO("select_many", "[select_many][map][operators]"){ +SCENARIO("select_many completes", "[select_many][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto scheduler = std::make_shared(); typedef rx::TestScheduler::Messages m; @@ -94,3 +94,186 @@ SCENARIO("select_many", "[select_many][map][operators]"){ } } } + +SCENARIO("select_many source never ends", "[select_many][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages ms; + + long invoked = 0; + + auto xs = scheduler->CreateColdObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(100, 4), + m::OnNext(200, 2), + m::OnNext(300, 3), + m::OnNext(400, 1), + m::OnNext(500, 5), + m::OnNext(700, 0) + }; + return m::ToVector(messages); + }() + ); + + auto ys = scheduler->CreateColdObservable( + []() { + ms::RecordedT messages[] = { + ms::OnNext(50, "foo"), + ms::OnNext(100, "bar"), + ms::OnNext(150, "baz"), + ms::OnNext(200, "qux"), + ms::OnCompleted(250) + }; + return ms::ToVector(messages); + }() + ); + + WHEN("each int is mapped to the strings"){ + + auto res = scheduler->Start( + [&]() { + return observable(from(xs) + .select_many([&](int){return ys;})); + } + ); + + THEN("the output contains strings repeated for each int"){ + ms::RecordedT items[] = { + ms::OnNext(350, "foo"), + ms::OnNext(400, "bar"), + ms::OnNext(450, "baz"), + ms::OnNext(450, "foo"), + ms::OnNext(500, "bar"), + ms::OnNext(500, "qux"), + ms::OnNext(550, "baz"), + ms::OnNext(550, "foo"), + ms::OnNext(600, "qux"), + ms::OnNext(600, "bar"), + ms::OnNext(650, "baz"), + ms::OnNext(650, "foo"), + ms::OnNext(700, "qux"), + ms::OnNext(700, "bar"), + ms::OnNext(750, "baz"), + ms::OnNext(750, "foo"), + ms::OnNext(800, "qux"), + ms::OnNext(800, "bar"), + ms::OnNext(850, "baz"), + ms::OnNext(900, "qux"), + ms::OnNext(950, "foo"), + ms::OnNext(1000, "bar") + }; + auto required = ms::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + rx::Subscription items[] = { + m::Subscribe(200, 1000) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + rx::Subscription items[] = { + ms::Subscribe(300, 550), + ms::Subscribe(400, 650), + ms::Subscribe(500, 750), + ms::Subscribe(600, 850), + ms::Subscribe(700, 950), + ms::Subscribe(900, 1000) + }; + auto required = m::ToVector(items); + auto actual = ys->Subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("select_many inner error", "[select_many][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + typedef rx::TestScheduler::Messages ms; + + long invoked = 0; + + auto xs = scheduler->CreateColdObservable( + []() { + m::RecordedT messages[] = { + m::OnNext(100, 4), + m::OnNext(200, 2), + m::OnNext(300, 3), + m::OnNext(400, 1), + m::OnCompleted(500) + }; + return m::ToVector(messages); + }() + ); + + auto ys = scheduler->CreateColdObservable( + []() { + ms::RecordedT messages[] = { + ms::OnNext(50, "foo"), + ms::OnNext(100, "bar"), + ms::OnNext(150, "baz"), + ms::OnNext(200, "qux"), + ms::OnError(300, std::exception()) + }; + return ms::ToVector(messages); + }() + ); + + WHEN("each int is mapped to the strings"){ + + auto res = scheduler->Start( + [&]() { + return observable(from(xs) + .select_many([&](int){return ys;})); + } + ); + + THEN("the output contains strings repeated for each int"){ + ms::RecordedT items[] = { + ms::OnNext(350, "foo"), + ms::OnNext(400, "bar"), + ms::OnNext(450, "foo"), + ms::OnNext(450, "baz"), + ms::OnNext(500, "bar"), + ms::OnNext(500, "qux"), + ms::OnNext(550, "baz"), + ms::OnNext(550, "foo"), + ms::OnError(600, std::exception()) + }; + auto required = ms::ToVector(items); + auto actual = res->Messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + rx::Subscription items[] = { + m::Subscribe(200, 600) + }; + auto required = m::ToVector(items); + auto actual = xs->Subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + rx::Subscription items[] = { + ms::Subscribe(300, 600), + ms::Subscribe(400, 600), + ms::Subscribe(500, 600) + }; + auto required = m::ToVector(items); + auto actual = ys->Subscriptions(); + REQUIRE(required == actual); + } + } + } +} \ No newline at end of file -- GitLab From 059934e59928fac58078d76bcb05504aad581272 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 17 Dec 2013 15:22:47 -0800 Subject: [PATCH 169/782] update version --- projects/nuget/rxcpp.autoconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig index b354d6c..9c6f05a 100644 --- a/projects/nuget/rxcpp.autoconfig +++ b/projects/nuget/rxcpp.autoconfig @@ -1,7 +1,7 @@ nuget { nuspec { id = rxcpp; - version : 1.0.0; + version : 1.0.1; title: Reactive Extensions for C++; authors: {Microsoft Open Technologies Inc.}; owners: {Microsoft Open Technologies Inc.}; -- GitLab From a9cc4f404e7957c6b69c84287886f2dc77e6652b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 19 Dec 2013 15:27:55 -0800 Subject: [PATCH 170/782] ensure that events do not overlap allowing events to overlap in the tests exposes them to differences in STL implementations. events at the same time may be processed in inverse order on one platform from the next. --- Rx/CPP/test/operators/SelectMany.cpp | 41 ++++++++++++++-------------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/Rx/CPP/test/operators/SelectMany.cpp b/Rx/CPP/test/operators/SelectMany.cpp index 9ab6602..afa4d22 100644 --- a/Rx/CPP/test/operators/SelectMany.cpp +++ b/Rx/CPP/test/operators/SelectMany.cpp @@ -219,11 +219,11 @@ SCENARIO("select_many inner error", "[select_many][map][operators]"){ auto ys = scheduler->CreateColdObservable( []() { ms::RecordedT messages[] = { - ms::OnNext(50, "foo"), - ms::OnNext(100, "bar"), - ms::OnNext(150, "baz"), - ms::OnNext(200, "qux"), - ms::OnError(300, std::exception()) + ms::OnNext(55, "foo"), + ms::OnNext(104, "bar"), + ms::OnNext(153, "baz"), + ms::OnNext(202, "qux"), + ms::OnError(301, std::exception()) }; return ms::ToVector(messages); }() @@ -240,15 +240,15 @@ SCENARIO("select_many inner error", "[select_many][map][operators]"){ THEN("the output contains strings repeated for each int"){ ms::RecordedT items[] = { - ms::OnNext(350, "foo"), - ms::OnNext(400, "bar"), - ms::OnNext(450, "foo"), - ms::OnNext(450, "baz"), - ms::OnNext(500, "bar"), - ms::OnNext(500, "qux"), - ms::OnNext(550, "baz"), - ms::OnNext(550, "foo"), - ms::OnError(600, std::exception()) + ms::OnNext(355, "foo"), + ms::OnNext(404, "bar"), + ms::OnNext(453, "baz"), + ms::OnNext(455, "foo"), + ms::OnNext(502, "qux"), + ms::OnNext(504, "bar"), + ms::OnNext(553, "baz"), + ms::OnNext(555, "foo"), + ms::OnError(601, std::exception()) }; auto required = ms::ToVector(items); auto actual = res->Messages(); @@ -257,7 +257,7 @@ SCENARIO("select_many inner error", "[select_many][map][operators]"){ THEN("there was one subscription and one unsubscription to the ints"){ rx::Subscription items[] = { - m::Subscribe(200, 600) + m::Subscribe(200, 601) }; auto required = m::ToVector(items); auto actual = xs->Subscriptions(); @@ -266,14 +266,15 @@ SCENARIO("select_many inner error", "[select_many][map][operators]"){ THEN("there were four subscription and unsubscription to the strings"){ rx::Subscription items[] = { - ms::Subscribe(300, 600), - ms::Subscribe(400, 600), - ms::Subscribe(500, 600) + ms::Subscribe(300, 601), + ms::Subscribe(400, 601), + ms::Subscribe(500, 601), + ms::Subscribe(600, 601) }; - auto required = m::ToVector(items); + auto required = ms::ToVector(items); auto actual = ys->Subscriptions(); REQUIRE(required == actual); } } } -} \ No newline at end of file +} -- GitLab From 2de529e4599bce629ab996c2a37911390f0195d7 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 19 Dec 2013 15:34:18 -0800 Subject: [PATCH 171/782] avoid more overlapping events --- Rx/CPP/test/operators/SelectMany.cpp | 63 ++++++++++++++-------------- 1 file changed, 31 insertions(+), 32 deletions(-) diff --git a/Rx/CPP/test/operators/SelectMany.cpp b/Rx/CPP/test/operators/SelectMany.cpp index afa4d22..9daef6c 100644 --- a/Rx/CPP/test/operators/SelectMany.cpp +++ b/Rx/CPP/test/operators/SelectMany.cpp @@ -120,11 +120,11 @@ SCENARIO("select_many source never ends", "[select_many][map][operators]"){ auto ys = scheduler->CreateColdObservable( []() { ms::RecordedT messages[] = { - ms::OnNext(50, "foo"), - ms::OnNext(100, "bar"), - ms::OnNext(150, "baz"), - ms::OnNext(200, "qux"), - ms::OnCompleted(250) + ms::OnNext(55, "foo"), + ms::OnNext(104, "bar"), + ms::OnNext(153, "baz"), + ms::OnNext(202, "qux"), + ms::OnCompleted(251) }; return ms::ToVector(messages); }() @@ -141,28 +141,27 @@ SCENARIO("select_many source never ends", "[select_many][map][operators]"){ THEN("the output contains strings repeated for each int"){ ms::RecordedT items[] = { - ms::OnNext(350, "foo"), - ms::OnNext(400, "bar"), - ms::OnNext(450, "baz"), - ms::OnNext(450, "foo"), - ms::OnNext(500, "bar"), - ms::OnNext(500, "qux"), - ms::OnNext(550, "baz"), - ms::OnNext(550, "foo"), - ms::OnNext(600, "qux"), - ms::OnNext(600, "bar"), - ms::OnNext(650, "baz"), - ms::OnNext(650, "foo"), - ms::OnNext(700, "qux"), - ms::OnNext(700, "bar"), - ms::OnNext(750, "baz"), - ms::OnNext(750, "foo"), - ms::OnNext(800, "qux"), - ms::OnNext(800, "bar"), - ms::OnNext(850, "baz"), - ms::OnNext(900, "qux"), - ms::OnNext(950, "foo"), - ms::OnNext(1000, "bar") + ms::OnNext(355, "foo"), + ms::OnNext(404, "bar"), + ms::OnNext(453, "baz"), + ms::OnNext(455, "foo"), + ms::OnNext(502, "qux"), + ms::OnNext(504, "bar"), + ms::OnNext(553, "baz"), + ms::OnNext(555, "foo"), + ms::OnNext(602, "qux"), + ms::OnNext(604, "bar"), + ms::OnNext(653, "baz"), + ms::OnNext(655, "foo"), + ms::OnNext(702, "qux"), + ms::OnNext(704, "bar"), + ms::OnNext(753, "baz"), + ms::OnNext(755, "foo"), + ms::OnNext(802, "qux"), + ms::OnNext(804, "bar"), + ms::OnNext(853, "baz"), + ms::OnNext(902, "qux"), + ms::OnNext(955, "foo") }; auto required = ms::ToVector(items); auto actual = res->Messages(); @@ -180,11 +179,11 @@ SCENARIO("select_many source never ends", "[select_many][map][operators]"){ THEN("there were four subscription and unsubscription to the strings"){ rx::Subscription items[] = { - ms::Subscribe(300, 550), - ms::Subscribe(400, 650), - ms::Subscribe(500, 750), - ms::Subscribe(600, 850), - ms::Subscribe(700, 950), + ms::Subscribe(300, 551), + ms::Subscribe(400, 651), + ms::Subscribe(500, 751), + ms::Subscribe(600, 851), + ms::Subscribe(700, 951), ms::Subscribe(900, 1000) }; auto required = m::ToVector(items); -- GitLab From 811950a150ca4fb00fc90a8ef7bf4432bedd7cec Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 19 Dec 2013 16:08:55 -0800 Subject: [PATCH 172/782] move throw() to only protect thread root and wndproc root --- Rx/CPP/src/cpprx/rx-base.hpp | 4 +- Rx/CPP/src/cpprx/rx-scheduler.hpp | 149 ++++++++++-------------------- Rx/CPP/src/cpprx/rx-windows.hpp | 24 ++--- 3 files changed, 65 insertions(+), 112 deletions(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 609265c..9424c9b 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -406,7 +406,7 @@ namespace rxcpp , work(std::move(work)) {} - static Disposable Do(Scheduler::Work& work, Scheduler::shared scheduler) throw() + static Disposable Do(Scheduler::Work& work, Scheduler::shared scheduler) { if (work) { @@ -426,7 +426,7 @@ namespace rxcpp public: typedef ScheduledItem QueueItem; - static Disposable Do(Work& work, const Scheduler::shared& scheduler) throw() + static Disposable Do(Work& work, const Scheduler::shared& scheduler) { return QueueItem::Do(work, scheduler); } diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp index 410c168..ed69bf4 100644 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ b/Rx/CPP/src/cpprx/rx-scheduler.hpp @@ -10,7 +10,7 @@ namespace rxcpp { ////////////////////////////////////////////////////////////////////// - // + // // schedulers struct CurrentThreadQueue @@ -21,18 +21,18 @@ namespace rxcpp private: ~CurrentThreadQueue(); - + struct compare_work { bool operator()(const QueueItem& work1, const QueueItem& work2) const { return work1.due > work2.due; } }; - + typedef std::priority_queue< QueueItem, std::vector, - compare_work + compare_work > ScheduledWork; public: @@ -46,11 +46,11 @@ namespace rxcpp RXCPP_THREAD_LOCAL static ThreadLocalQueue* queue; return queue; } - + public: - static Scheduler::shared GetScheduler() { - return !!threadLocalQueue() ? threadLocalQueue()->scheduler : Scheduler::shared(); + static Scheduler::shared GetScheduler() { + return !!threadLocalQueue() ? threadLocalQueue()->scheduler : Scheduler::shared(); } static bool empty() { if (!threadLocalQueue()) { @@ -126,7 +126,7 @@ namespace rxcpp } static bool IsScheduleRequired() { return false; } - + using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { @@ -146,13 +146,13 @@ namespace rxcpp } static bool IsScheduleRequired() { return !CurrentThreadQueue::GetScheduler(); } - + using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { auto localScheduler = CurrentThreadQueue::GetScheduler(); // check ownership - if (!!localScheduler) + if (!!localScheduler) { // already has an owner - delegate return localScheduler->Schedule(dueTime, std::move(work)); @@ -178,9 +178,9 @@ namespace rxcpp auto work = CurrentThreadQueue::top().work; CurrentThreadQueue::pop(); - + Do(work, get()); - + if (CurrentThreadQueue::empty()) {break;} } @@ -192,7 +192,7 @@ namespace rxcpp { private: ImmediateScheduler(const ImmediateScheduler&); - + mutable std::mutex lock; mutable bool hasFaulted; mutable bool isAquired; @@ -224,7 +224,7 @@ namespace rxcpp } } - if (isOwner) + if (isOwner) { RXCPP_UNWIND_AUTO([&](){ std::unique_lock guard(lock); @@ -233,10 +233,10 @@ namespace rxcpp isAquired = false; }); - for(;;) + for(;;) { std::this_thread::sleep_until(item.due); - try + try { Do(item.work, queue->scheduler); } @@ -268,10 +268,10 @@ namespace rxcpp } } }; - + template - class ScheduledObserver : - public Observer, + class ScheduledObserver : + public Observer, public std::enable_shared_from_this> { typedef std::function Action; @@ -312,14 +312,14 @@ namespace rxcpp this->observer->OnNext(std::move(element)); })); } - virtual void OnCompleted() + virtual void OnCompleted() { std::unique_lock guard(lock); queue.push(Action([=](){ this->observer->OnCompleted(); })); } - virtual void OnError(const std::exception_ptr& error) + virtual void OnError(const std::exception_ptr& error) { std::unique_lock guard(lock); queue.push(Action([=](){ @@ -369,7 +369,7 @@ namespace rxcpp } } - try + try { action(); } @@ -416,7 +416,7 @@ namespace rxcpp typedef std::function Factory; static bool IsScheduleRequired() { return false; } - + typedef std::tuple, Disposable> EnsureThreadResult; EnsureThreadResult EnsureThread(Factory& factory, Scheduler::shared owner, clock::time_point dueTime, Work work) { @@ -438,7 +438,7 @@ namespace rxcpp auto local = std::static_pointer_cast(shared_from_this()); auto localQueue = queue; - std::get<0>(result).set(factory([local, localQueue]{ + std::get<0>(result).set(factory([local, localQueue] { local->Run(localQueue);})); isOwner = !isAquired; @@ -458,7 +458,7 @@ namespace rxcpp } private: - void Run(CurrentThreadQueue::ThreadLocalQueue* queue) { + void Run(CurrentThreadQueue::ThreadLocalQueue* queue) throw() { auto keepAlive = shared_from_this(); { std::unique_lock guard(lock); @@ -467,35 +467,15 @@ namespace rxcpp isAquired = false;}); RXCPP_UNWIND(unwindQueue, [&](){ - CurrentThreadQueue::DestroyQueue(); + CurrentThreadQueue::DestroyQueue(); queue = nullptr;}); CurrentThreadQueue::SetQueue(queue); -#if 0 - auto start = queue->scheduler->Now(); - auto ms = std::chrono::milliseconds(1); -#endif while(!CurrentThreadQueue::empty()) { auto now = queue->scheduler->Now(); -#if 0 - {std::wstringstream out; - out << L"eventloop (run) pending: " << std::boolalpha << CurrentThreadQueue::empty() - << L", now: " << ((now - start) / ms); - if (!CurrentThreadQueue::empty()) { - out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} - out << std::endl; - OutputDebugString(out.str().c_str());} -#endif if (CurrentThreadQueue::empty()) { -#if 0 - {std::wstringstream out; - out << L"eventloop (wait for work) pending: " << std::boolalpha << CurrentThreadQueue::empty() - << L", now: " << ((now - start) / ms); - out << std::endl; - OutputDebugString(out.str().c_str());} -#endif wake.wait(guard, [&](){ return !CurrentThreadQueue::empty();}); continue; @@ -503,46 +483,19 @@ namespace rxcpp auto item = &CurrentThreadQueue::top(); if (!item->work) { -#if 0 - {std::wstringstream out; - out << L"eventloop (pop disposed work) pending: " << std::boolalpha << CurrentThreadQueue::empty() - << L", now: " << ((now - start) / ms); - if (!CurrentThreadQueue::empty()) { - out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} - out << std::endl; - OutputDebugString(out.str().c_str());} -#endif CurrentThreadQueue::pop(); continue;} - + // wait until the work is due if (now < item->due) { -#if 0 - {std::wstringstream out; - out << L"eventloop (wait for due) pending: " << std::boolalpha << CurrentThreadQueue::empty() - << L", now: " << ((now - start) / ms); - if (!CurrentThreadQueue::empty()) { - out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} - out << std::endl; - OutputDebugString(out.str().c_str());} -#endif wake.wait_until(guard, item->due); continue; } -#if 0 - {std::wstringstream out; - out << L"eventloop (dispatch) pending: " << std::boolalpha << CurrentThreadQueue::empty() - << L", now: " << ((now - start) / ms); - if (!CurrentThreadQueue::empty()) { - out << L", due: " << ((CurrentThreadQueue::top().due - start) / ms);} - out << std::endl; - OutputDebugString(out.str().c_str());} -#endif // dispatch work auto work = item->work; CurrentThreadQueue::pop(); - + RXCPP_UNWIND_AUTO([&]{ guard.lock();}); guard.unlock(); @@ -566,7 +519,7 @@ namespace rxcpp }; } template - EventLoopScheduler(Factory factoryarg) + EventLoopScheduler(Factory factoryarg) : factory(std::move(factoryarg)) , derecurser(std::make_shared()) { @@ -579,7 +532,7 @@ namespace rxcpp } static bool IsScheduleRequired() { return !CurrentThreadQueue::GetScheduler(); } - + using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { @@ -595,18 +548,18 @@ namespace rxcpp return std::move(std::get<1>(maybeThread)); } }; - + struct NewThreadScheduler : public LocalScheduler { public: typedef std::function)> Factory; private: NewThreadScheduler(const NewThreadScheduler&); - + Factory factory; public: - - + + NewThreadScheduler() : factory([](std::function start){return std::thread(std::move(start));}) { } @@ -616,7 +569,7 @@ namespace rxcpp virtual ~NewThreadScheduler() { } - + using LocalScheduler::Schedule; virtual Disposable Schedule(clock::time_point dueTime, Work work) { @@ -641,11 +594,11 @@ namespace rxcpp return work1.due > work2.due; } }; - + typedef std::priority_queue< QueueItem, std::vector, - compare_work + compare_work > ScheduledWork; ScheduledWork queue; @@ -690,7 +643,7 @@ namespace rxcpp cancelable.Dispose(); return Base::Do(local, std::move(scheduler)); }; - + cancelable = run; auto si = QueueItem(dueTime, cancelable); @@ -714,43 +667,43 @@ namespace rxcpp static const long Disposed = 1000; template - struct Messages + struct Messages { typedef Recorded>> RecordedT; - static + static RecordedT OnNext(long ticks, T value) { return RecordedT(ticks, Notification::CreateOnNext(value)); } - static + static RecordedT OnCompleted(long ticks) { return RecordedT(ticks, Notification::CreateOnCompleted()); } - static + static RecordedT OnError(long ticks, std::exception_ptr ep) { return RecordedT(ticks, Notification::CreateOnError(ep)); } template - static + static RecordedT OnError(long ticks, Exception e) { return RecordedT(ticks, Notification::CreateOnError(e)); } - static + static Subscription Subscribe(long subscribe, long unsubscribe) { return Subscription(subscribe, unsubscribe); } template - static + static auto ToVector(const Item (&arr) [size]) -> std::vector { return std::vector(std::begin(arr), std::end(arr)); } @@ -789,7 +742,7 @@ namespace rxcpp { auto observer = CreateObserver(); - struct State + struct State { std::shared_ptr> source; SerialDisposable subscription; @@ -799,11 +752,11 @@ namespace rxcpp state->observer = observer; - ScheduleAbsolute(created, [create, state](Scheduler::shared scheduler) -> Disposable { + ScheduleAbsolute(created, [create, state](Scheduler::shared scheduler) -> Disposable { state->source = create(); return Disposable::Empty(); }); - ScheduleAbsolute(subscribed, [state](Scheduler::shared scheduler) -> Disposable { + ScheduleAbsolute(subscribed, [state](Scheduler::shared scheduler) -> Disposable { state->subscription.Set(state->source->Subscribe(state->observer)); return Disposable::Empty(); }); - ScheduleAbsolute(disposed, [state](Scheduler::shared scheduler) -> Disposable { + ScheduleAbsolute(disposed, [state](Scheduler::shared scheduler) -> Disposable { state->subscription.Dispose(); return Disposable::Empty(); }); Start(); @@ -907,8 +860,8 @@ namespace rxcpp for (auto& message : messages) { auto notification = message.Value(); - d.Add(scheduler->ScheduleRelative(message.Time(), [notification, observer](Scheduler::shared) -> Disposable { - notification->Accept(observer); return Disposable::Empty(); + d.Add(scheduler->ScheduleRelative(message.Time(), [notification, observer](Scheduler::shared) -> Disposable { + notification->Accept(observer); return Disposable::Empty(); })); } diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp index 5284744..06b2fb9 100644 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ b/Rx/CPP/src/cpprx/rx-windows.hpp @@ -15,7 +15,7 @@ #include namespace rxcpp { namespace win32 { - + #if !defined(OBSERVE_ON_DISPATCHER_OP) #define OBSERVE_ON_DISPATCHER_OP rxcpp::win32::ObserveOnDispatcherOp @@ -51,7 +51,7 @@ namespace rxcpp { namespace win32 { if (!RegisterClass(&wndclass)) throw std::exception("error"); - + } HWND CreateWindow_() { @@ -71,7 +71,7 @@ namespace rxcpp { namespace win32 { return DefWindowProc(hwnd, message, wParam, lParam); } } - static WindowClass& Instance() { + static WindowClass& Instance() { static WindowClass instance; return instance; } @@ -103,7 +103,7 @@ namespace rxcpp { namespace win32 { return work1.first > work2.first; } }; - + struct Queue; typedef std::pair Item; @@ -112,10 +112,10 @@ namespace rxcpp { namespace win32 { typedef std::priority_queue< PriorityItem, std::vector, - compare_work + compare_work > ScheduledWork; - struct Queue + struct Queue { Queue() : exit(false), window(NULL) {} bool exit; @@ -143,7 +143,7 @@ namespace rxcpp { namespace win32 { wndclass.lpszClassName = className(); RegisterClassW(&wndclass); - + std::unique_ptr that(new WindowClass); that->queue = queue; @@ -156,7 +156,7 @@ namespace rxcpp { namespace win32 { static const int WM_USER_DISPATCH = WM_USER + 1; - static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) throw() { WindowClass* windowClass = reinterpret_cast(GetWindowLongPtr(hwnd, GWLP_USERDATA)); switch (message) @@ -190,10 +190,10 @@ namespace rxcpp { namespace win32 { } if (!windowClass->queue->scheduledWork.empty()) - { + { auto& item = windowClass->queue->scheduledWork.top(); auto now = item.second.get()->first->Now(); - + // wait until the work is due if(now < item.first) { @@ -204,7 +204,7 @@ namespace rxcpp { namespace win32 { } std::this_thread::sleep_until(item.first); } - + // dispatch work auto work = std::move(item.second.get()->second); auto scheduler = std::move(item.second.get()->first); @@ -230,7 +230,7 @@ namespace rxcpp { namespace win32 { if (destroy) { - DestroyWindow(window); + DestroyWindow(window); } } return 0; -- GitLab From a4a1d81da1905bcab110ce6b78f2fe992fab91e7 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 19 Dec 2013 16:17:27 -0800 Subject: [PATCH 173/782] missed a throw() --- Rx/CPP/src/cpprx/rx-base.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp index 9424c9b..43acb56 100644 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ b/Rx/CPP/src/cpprx/rx-base.hpp @@ -494,7 +494,7 @@ namespace rxcpp virtual util::maybe GetNext() =0; public: - static Disposable Do(Work& work, const Scheduler::shared& scheduler) throw() + static Disposable Do(Work& work, const Scheduler::shared& scheduler) { return QueueItem::Do(work, scheduler); } -- GitLab From 102645582411af0dba7d2703a1539f6699b1f2e7 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sun, 26 Jan 2014 15:26:00 -0800 Subject: [PATCH 174/782] increment nuget package version --- projects/nuget/rxcpp.autoconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig index 9c6f05a..7c002d0 100644 --- a/projects/nuget/rxcpp.autoconfig +++ b/projects/nuget/rxcpp.autoconfig @@ -1,7 +1,7 @@ nuget { nuspec { id = rxcpp; - version : 1.0.1; + version : 1.0.2; title: Reactive Extensions for C++; authors: {Microsoft Open Technologies Inc.}; owners: {Microsoft Open Technologies Inc.}; -- GitLab From 800253ff880da40ec5cc04be7afa129f78945b3d Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 20 Feb 2014 08:00:20 -0800 Subject: [PATCH 175/782] add failing test for issue 5 --- Rx/CPP/test/operators/Merge.cpp | 60 +++++++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 61 insertions(+) create mode 100644 Rx/CPP/test/operators/Merge.cpp diff --git a/Rx/CPP/test/operators/Merge.cpp b/Rx/CPP/test/operators/Merge.cpp new file mode 100644 index 0000000..7e26d8f --- /dev/null +++ b/Rx/CPP/test/operators/Merge.cpp @@ -0,0 +1,60 @@ +#include "cpprx/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("merge issue 5", "[merge][issue][operators]"){ + GIVEN("Empty and Never"){ + auto scheduler = std::make_shared(); + typedef rx::TestScheduler::Messages m; + + WHEN("merged 4 times"){ + + std::vector empty; + auto o = rx::observable(rx::from(rx::Iterate(empty)) + .merge(rx::Never())); + + auto res1 = scheduler->Start( + [o]() { + return o; + } + ); + auto res2 = scheduler->Start( + [o]() { + return o; + } + ); + auto res3 = scheduler->Start( + [o]() { + return o; + } + ); + auto res4 = scheduler->Start( + [o]() { + return o; + } + ); + + THEN("1 - the output is empty and subscribed"){ + std::vector required; + auto actual = res1->Messages(); + REQUIRE(required == actual); + } + THEN("2 - the output is empty and subscribed"){ + std::vector required; + auto actual = res2->Messages(); + REQUIRE(required == actual); + } + THEN("3 - the output is empty and subscribed"){ + std::vector required; + auto actual = res3->Messages(); + REQUIRE(required == actual); + } + THEN("4 - the output is empty and subscribed"){ + std::vector required; + auto actual = res4->Messages(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 3933df6..bd4e4b6 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -22,6 +22,7 @@ include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXC # define the sources of the self test set(TEST_SOURCES ${TEST_DIR}/test.cpp + ${TEST_DIR}/operators/Merge.cpp ${TEST_DIR}/operators/Return.cpp ${TEST_DIR}/operators/Select.cpp ${TEST_DIR}/operators/SelectMany.cpp -- GitLab From bfaf418a9fdf9fd4bffc8845e2e56ce9da351f37 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 20 Feb 2014 08:16:19 -0800 Subject: [PATCH 176/782] fix for issue 5, state was shared across subscriptions --- Rx/CPP/src/cpprx/operators/Merge.hpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/Rx/CPP/src/cpprx/operators/Merge.hpp b/Rx/CPP/src/cpprx/operators/Merge.hpp index 793acdf..4a724ca 100644 --- a/Rx/CPP/src/cpprx/operators/Merge.hpp +++ b/Rx/CPP/src/cpprx/operators/Merge.hpp @@ -62,7 +62,9 @@ namespace rxcpp { typedef MergeSource result_type; typedef decltype(std::make_tuple(firstSource, otherSource...)) Sources; - struct State { + struct State + : std::enable_shared_from_this + { typedef Sources Sources; typedef result_type result_type; typedef std::tuple_size SourcesSize; @@ -72,11 +74,11 @@ namespace rxcpp std::atomic pendingComplete; }; Sources sources(firstSource, otherSource...); - // bug on osx prevents using make_shared - std::shared_ptr state(new State()); return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { + // bug on osx prevents using make_shared + std::shared_ptr state(new State()); ComposableDisposable cd; detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); return cd; @@ -91,7 +93,9 @@ namespace rxcpp { typedef MergeSource result_type; typedef decltype(std::make_tuple(firstSource, otherSource)) Sources; - struct State { + struct State + : std::enable_shared_from_this + { typedef Sources Sources; typedef result_type result_type; typedef std::tuple_size SourcesSize; @@ -101,11 +105,11 @@ namespace rxcpp std::atomic pendingComplete; }; Sources sources(firstSource, otherSource); - // bug on osx prevents using make_shared - std::shared_ptr state(new State()); return CreateObservable( [=](std::shared_ptr> observer) -> Disposable { + // bug on osx prevents using make_shared + std::shared_ptr state(new State()); ComposableDisposable cd; detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); return cd; -- GitLab From b99e75cda3861f3bb8621befe1fbca32949c15e0 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 28 Jan 2014 23:57:54 -0800 Subject: [PATCH 177/782] explore static observer --- Rx/CPP/src/rxcpp/rx.hpp | 627 ++++++++++++++++++ Rx/CPP/test/v2/subscriptions/observer.cpp | 190 ++++++ Rx/CPP/test/v2/subscriptions/subscription.cpp | 181 +++++ projects/CMake/CMakeLists.txt | 2 + 4 files changed, 1000 insertions(+) create mode 100644 Rx/CPP/src/rxcpp/rx.hpp create mode 100644 Rx/CPP/test/v2/subscriptions/observer.cpp create mode 100644 Rx/CPP/test/v2/subscriptions/subscription.cpp diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp new file mode 100644 index 0000000..c9a8157 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -0,0 +1,627 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_HPP) +#define RXCPP_RX_HPP + +#include +#include +#include +#include +#include +#include +#include + +namespace rxcpp { + + struct tag_subscription {}; + struct subscription_base {typedef tag_subscription subscription_tag;}; + template + class is_subscription + { + template + static typename C::subscription_tag check(int); + template + static void check(...); + public: + static const bool value = std::is_same(0)), tag_subscription>::value; + }; + + class dynamic_subscription : public subscription_base + { + typedef std::function unsubscribe_call_type; + unsubscribe_call_type unsubscribe_call; + dynamic_subscription() + { + } + public: + dynamic_subscription(const dynamic_subscription& o) + : unsubscribe_call(o.unsubscribe_call) + { + } + dynamic_subscription(dynamic_subscription&& o) + : unsubscribe_call(std::move(o.unsubscribe_call)) + { + } + template + dynamic_subscription(I i, typename std::enable_if::value && !std::is_same::value, void**>::type selector = nullptr) + : unsubscribe_call([i](){ + i.unsubscribe();}) + { + } + dynamic_subscription(unsubscribe_call_type s) + : unsubscribe_call(std::move(s)) + { + } + void unsubscribe() const { + unsubscribe_call(); + } + }; + + template + class static_subscription : public subscription_base + { + typedef Unsubscribe unsubscribe_call_type; + unsubscribe_call_type unsubscribe_call; + static_subscription() + { + } + public: + static_subscription(const static_subscription& o) + : unsubscribe_call(o.unsubscribe_call) + { + } + static_subscription(static_subscription&& o) + : unsubscribe_call(std::move(o.unsubscribe_call)) + { + } + static_subscription(unsubscribe_call_type s) + : unsubscribe_call(std::move(s)) + { + } + void unsubscribe() const { + unsubscribe_call(); + } + }; + + template + class subscription : public subscription_base + { + typedef I inner_t; + inner_t inner; + mutable bool issubscribed; + public: + subscription(inner_t inner) + : inner(std::move(inner)) + , issubscribed(true) + { + } + bool is_subscribed() const { + return issubscribed; + } + void unsubscribe() const { + if (issubscribed) { + inner.unsubscribe(); + } + issubscribed = false; + } + }; + template<> + class subscription : public subscription_base + { + public: + subscription() + { + } + bool is_subscribed() const { + return false; + } + void unsubscribe() const { + } + }; + inline auto make_subscription() + -> subscription { + return subscription(); + } + template + auto make_subscription(I i) + -> typename std::enable_if::value, + subscription>::type { + return subscription(std::move(i)); + } + template + auto make_subscription(Unsubscribe u) + -> typename std::enable_if::value, + subscription< static_subscription>>::type { + return subscription< static_subscription>( + static_subscription(std::move(u))); + } + + class composite_subscription : public subscription_base + { + public: + typedef std::shared_ptr shared_subscription; + typedef std::weak_ptr weak_subscription; + private: + struct state_t + { + std::vector subscriptions; + std::mutex lock; + bool issubscribed; + + state_t() + : issubscribed(true) + { + } + + bool is_subscribed() { + return issubscribed; + } + + weak_subscription add(dynamic_subscription s) { + return add(std::make_shared(std::move(s))); + } + + weak_subscription add(shared_subscription s) { + std::unique_lock guard(lock); + + if (!issubscribed) { + s->unsubscribe(); + } else { + auto end = std::end(subscriptions); + auto it = std::find(std::begin(subscriptions), end, s); + if (it == end) + { + subscriptions.emplace_back(std::move(s)); + } + } + return s; + } + + void remove(weak_subscription w) { + std::unique_lock guard(lock); + + auto s = w.lock(); + if (s) + { + auto end = std::end(subscriptions); + auto it = std::find(std::begin(subscriptions), end, s); + if (it != end) + { + subscriptions.erase(it); + } + } + } + + void clear() { + std::unique_lock guard(lock); + + if (issubscribed) { + std::vector v(std::move(subscriptions)); + std::for_each(v.begin(), v.end(), + [](shared_subscription& s) { + s->unsubscribe(); }); + } + } + + void unsubscribe() { + std::unique_lock guard(lock); + + if (issubscribed) { + issubscribed = false; + std::vector v(std::move(subscriptions)); + std::for_each(v.begin(), v.end(), + [](shared_subscription& s) { + s->unsubscribe(); }); + } + } + }; + + mutable std::shared_ptr state; + + public: + + composite_subscription() + : state(std::make_shared()) + { + } + composite_subscription(const composite_subscription& o) + : state(o.state) + { + } + composite_subscription(composite_subscription&& o) + : state(std::move(o.state)) + { + } + + composite_subscription& operator=(const composite_subscription& o) + { + state = o.state; + return *this; + } + composite_subscription& operator=(composite_subscription&& o) + { + state = std::move(o.state); + return *this; + } + + bool is_subscribed() const { + return state->is_subscribed(); + } + weak_subscription add(shared_subscription s) const { + return state->add(std::move(s)); + } + weak_subscription add(dynamic_subscription s) const { + return state->add(std::move(s)); + } + void remove(weak_subscription w) const { + state->remove(w); + } + void clear() const { + state->clear(); + } + void unsubscribe() const { + state->unsubscribe(); + } + }; + + struct tag_observer {}; + template + struct observer_root : public subscription_base + { + typedef T value_type; + typedef composite_subscription subscription_type; + typedef typename subscription_type::weak_subscription weak_subscription; + typedef tag_observer observer_tag; + }; + template + struct observer_base : public observer_root + { + private: + subscription_type s; + + observer_base(); + public: + observer_base(subscription_type s) + : s(std::move(s)) + { + } + observer_base(const observer_base& o) + : s(o.s) + { + } + observer_base(observer_base&& o) + : s(std::move(o.s)) + { + } + observer_base& operator=(observer_base o) { + swap(o); + return *this; + } + void swap(observer_base& o) { + using std::swap; + swap(s, o.s); + } + bool is_subscribed() { + return s.is_subscribed(); + } + weak_subscription add(dynamic_subscription ds) { + return s.add(std::move(ds)); + } + void remove(weak_subscription ws) { + s.remove(ws); + } + void unsubscribe() { + s.unsubscribe(); + } + }; + template + struct observer_base : public observer_root + { + void swap(observer_base&) { + } + bool is_subscribed() { + return false; + } + weak_subscription add(dynamic_subscription ds) { + ds.unsubscribe(); + return weak_subscription(); + } + void remove(weak_subscription) { + } + void unsubscribe() { + } + }; + template + class is_observer + { + template + static typename C::observer_tag check(int); + template + static void check(...); + public: + static const bool value = std::is_same(0)), tag_observer>::value; + }; + +namespace detail { + struct OnErrorEmpty + { + void operator()(std::exception_ptr&&){} + }; + struct OnCompletedEmpty + { + void operator()(){} + }; +} + + template + class dynamic_observer : public observer_base + { + public: + typedef std::function on_next_t; + typedef std::function on_error_t; + typedef std::function on_completed_t; + + private: + on_next_t onnext; + on_error_t onerror; + on_completed_t oncompleted; + + public: + dynamic_observer() + { + } + dynamic_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) + : observer_base(std::move(cs)) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + dynamic_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) + : observer_base(composite_subscription()) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + dynamic_observer(const dynamic_observer& o) + : observer_base(o) + , onnext(o.onnext) + , onerror(o.onerror) + , oncompleted(o.oncompleted) + { + } + dynamic_observer(dynamic_observer&& o) + : observer_base(std::move(o)) + , onnext(std::move(o.onnext)) + , onerror(std::move(o.onerror)) + , oncompleted(std::move(o.oncompleted)) + { + } + dynamic_observer& operator=(dynamic_observer o) { + swap(o); + return *this; + } + void swap(dynamic_observer& o) { + using std::swap; + observer_base::swap(o); + swap(onnext, o.onnext); + swap(onerror, o.onerror); + swap(oncompleted, o.oncompleted); + } + + void on_next(T t) { + if (onnext) { + onnext(std::move(t)); + } + } + void on_error(std::exception_ptr e) { + if (onerror) { + onerror(e); + } + } + void on_completed() { + if (oncompleted) { + oncompleted(); + } + } + }; + + template + class static_observer : public observer_base + { + public: + typedef OnNext on_next_t; + typedef OnError on_error_t; + typedef OnCompleted on_completed_t; + + private: + on_next_t onnext; + on_error_t onerror; + on_completed_t oncompleted; + + public: + static_observer() + { + } + static_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) + : observer_base(std::move(cs)) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + static_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) + : observer_base(composite_subscription()) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + static_observer(const static_observer& o) + : observer_base(o) + , onnext(o.onnext) + , onerror(o.onerror) + , oncompleted(o.oncompleted) + { + } + static_observer(static_observer&& o) + : observer_base(std::move(o)) + , onnext(std::move(o.onnext)) + , onerror(std::move(o.onerror)) + , oncompleted(std::move(o.oncompleted)) + { + } + static_observer& operator=(static_observer o) { + swap(o); + return *this; + } + void swap(static_observer& o) { + using std::swap; + observer_base::swap(o); + swap(onnext, o.onnext); + swap(onerror, o.onerror); + swap(oncompleted, o.oncompleted); + } + + void on_next(T t) { + onnext(std::move(t)); + } + void on_error(std::exception_ptr e) { + onerror(e); + } + void on_completed() { + oncompleted(); + } + }; + + template + class observer : public observer_root + { + typedef + typename std::conditional::value, I, dynamic_observer>::type + inner_t; + inner_t inner; + public: + ~observer() + { + } + observer(inner_t inner) + : inner(std::move(inner)) + { + } + void on_next(T t) { + if (is_subscribed()) { + inner.on_next(std::move(t)); + } + } + void on_error(std::exception_ptr e) { + if (is_subscribed()) { + inner.on_error(e); + } + unsubscribe(); + } + void on_completed() { + if (is_subscribed()) { + inner.on_completed(); + } + unsubscribe(); + } + bool is_subscribed() { + return inner.is_subscribed(); + } + weak_subscription add(dynamic_subscription ds) { + return inner.add(std::move(ds)); + } + void remove(weak_subscription ws) { + inner.remove(ws); + } + void unsubscribe() { + inner.unsubscribe(); + } + }; + template + class observer : public observer_base + { + public: + observer() + { + } + void on_next(T&&) { + } + void on_error(std::exception_ptr) { + } + void on_completed() { + } + }; + template + auto make_observer() + -> observer { + return observer(); + } + template + auto make_observer(I i) + -> typename std::enable_if::value, observer>::type { + return observer(std::move(i)); + } + template + auto make_observer(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) + -> observer> { + return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); + } + template + auto make_observer(OnNext n, OnError e, OnCompleted c) + -> observer> { + return observer>( + static_observer(std::move(n), std::move(e), std::move(c))); + } + template + auto make_observer(OnNext n, OnError e) + -> observer> { + return observer>( + static_observer(std::move(n), std::move(e), detail::OnCompletedEmpty())); + } + template + auto make_observer(OnNext n) + -> typename std::enable_if::value, + observer>>::type { + return observer>( + static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); + } + +#if 0 + template + class observable + { + public: + ~observable(); + + observable(const observable& o) + : onsubscribe(o.onsubscribe) + { + } + observable(observable&& o) + : onsubscribe(std::move(o.onsubscribe)) + { + } + + observable(on_subscribe_t os) + : onsubscribe(std::move(os)) + { + } + + static observable create(on_subscribe_t os) { + return observable(std::move(os)); + } + static observable create(const subscribe_t& s) { + return observable([s](observer o){ + o.add(s(o)); + }); + } + }; +#endif + +} +#endif diff --git a/Rx/CPP/test/v2/subscriptions/observer.cpp b/Rx/CPP/test/v2/subscriptions/observer.cpp new file mode 100644 index 0000000..25150c4 --- /dev/null +++ b/Rx/CPP/test/v2/subscriptions/observer.cpp @@ -0,0 +1,190 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("observer traits", "[observer][traits]"){ + GIVEN("given some observer types"){ + auto emptyNext = [](int){}; + rx::dynamic_observer dob(emptyNext); + auto so = rx::make_observer(emptyNext); + auto eo = rx::make_observer(); + WHEN("tested"){ + THEN("is_observer value is true for dynamic_observer"){ + REQUIRE(rx::is_observer::value); + } + THEN("is_observer value is true for static_observer"){ + REQUIRE(rx::is_observer::value); + } + THEN("is_observer value is true for observer"){ + REQUIRE(rx::is_observer::value); + } + } + } +} + +SCENARIO("non-observer traits", "[observer][traits]"){ + GIVEN("given some subscription types"){ + auto empty = [](){}; + rx::dynamic_subscription ds(empty); + rx::static_subscription ss(empty); + auto es = rx::make_subscription(); + rx::composite_subscription cs; + WHEN("tested"){ + THEN("is_observer value is false for dynamic_subscription"){ + REQUIRE(!rx::is_observer::value); + } + THEN("is_observer value is false for static_subscription"){ + REQUIRE(!rx::is_observer::value); + } + THEN("is_observer value is false for subscription"){ + REQUIRE(!rx::is_observer::value); + } + THEN("is_observer value is false for composite_subscription"){ + REQUIRE(!rx::is_observer::value); + } + } + } +} + +SCENARIO("observers with subscription traits", "[observer][subscription][traits]"){ + GIVEN("given some observer types"){ + auto emptyNext = [](int){}; + rx::dynamic_observer dob(emptyNext); + auto so = rx::make_observer(emptyNext); + auto eo = rx::make_observer(); + WHEN("tested"){ + THEN("is_subscription value is true for dynamic_observer"){ + REQUIRE(rx::is_subscription::value); + } + THEN("is_subscription value is true for static_observer"){ + REQUIRE(rx::is_subscription::value); + } + THEN("is_subscription value is true for observer"){ + REQUIRE(rx::is_subscription::value); + } + } + } +} + +SCENARIO("observer behavior", "[observer][traits]"){ + GIVEN("given some observer types"){ + int result = 0; + auto next = [&result](int i){result += i;}; + auto error = [&result](std::exception_ptr){result += 10;}; + auto completed = [&result](){result += 100;}; + auto dob = rx::make_observer(rx::dynamic_observer(next, error, completed)); + auto so = rx::make_observer(next, error, completed); + auto eo = rx::make_observer(); + WHEN("nothing is called"){ + THEN("dynamic_observer result is 0"){ + REQUIRE(result == 0); + } + THEN("static_observer result is 0"){ + REQUIRE(result == 0); + } + THEN("observer result is 0"){ + REQUIRE(result == 0); + } + THEN("dynamic_observer is subscribed"){ + REQUIRE(dob.is_subscribed()); + } + THEN("static_observer is subscribed"){ + REQUIRE(so.is_subscribed()); + } + THEN("observer is subscribed"){ + REQUIRE(!eo.is_subscribed()); + } + } + WHEN("onnext is called with 1"){ + THEN("dynamic_observer result is 1"){ + dob.on_next(1); + REQUIRE(result == 1); + } + THEN("static_observer result is 1"){ + so.on_next(1); + REQUIRE(result == 1); + } + THEN("observer result is 0"){ + eo.on_next(1); + REQUIRE(result == 0); + } + THEN("dynamic_observer is subscribed"){ + dob.on_next(1); + REQUIRE(dob.is_subscribed()); + } + THEN("static_observer is subscribed"){ + so.on_next(1); + REQUIRE(so.is_subscribed()); + } + THEN("observer is not subscribed"){ + eo.on_next(1); + REQUIRE(!eo.is_subscribed()); + } + } + WHEN("onnext is called with 1 after error"){ + THEN("dynamic_observer result is 10"){ + dob.on_error(std::current_exception()); + dob.on_next(1); + REQUIRE(result == 10); + } + THEN("static_observer result is 10"){ + so.on_error(std::current_exception()); + so.on_next(1); + REQUIRE(result == 10); + } + THEN("observer result is 0"){ + eo.on_error(std::current_exception()); + eo.on_next(1); + REQUIRE(result == 0); + } + THEN("dynamic_observer is not subscribed"){ + dob.on_error(std::current_exception()); + dob.on_next(1); + REQUIRE(!dob.is_subscribed()); + } + THEN("static_observer is not subscribed"){ + so.on_error(std::current_exception()); + so.on_next(1); + REQUIRE(!so.is_subscribed()); + } + THEN("observer is not subscribed"){ + eo.on_error(std::current_exception()); + eo.on_next(1); + REQUIRE(!eo.is_subscribed()); + } + } + WHEN("onnext is called with 1 after completed"){ + THEN("dynamic_observer result is 100"){ + dob.on_completed(); + dob.on_next(1); + REQUIRE(result == 100); + } + THEN("static_observer result is 100"){ + so.on_completed(); + so.on_next(1); + REQUIRE(result == 100); + } + THEN("observer result is 0"){ + eo.on_completed(); + eo.on_next(1); + REQUIRE(result == 0); + } + THEN("dynamic_observer is not subscribed"){ + dob.on_completed(); + dob.on_next(1); + REQUIRE(!dob.is_subscribed()); + } + THEN("static_observer is not subscribed"){ + so.on_completed(); + so.on_next(1); + REQUIRE(!so.is_subscribed()); + } + THEN("observer is not subscribed"){ + eo.on_completed(); + eo.on_next(1); + REQUIRE(!eo.is_subscribed()); + } + } + } +} diff --git a/Rx/CPP/test/v2/subscriptions/subscription.cpp b/Rx/CPP/test/v2/subscriptions/subscription.cpp new file mode 100644 index 0000000..3244946 --- /dev/null +++ b/Rx/CPP/test/v2/subscriptions/subscription.cpp @@ -0,0 +1,181 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +SCENARIO("subscription traits", "[subscription][traits]"){ + GIVEN("given some subscription types"){ + auto empty = [](){}; + rx::dynamic_subscription ds(empty); + rx::static_subscription ss(empty); + auto es = rx::make_subscription(); + rx::composite_subscription cs; + WHEN("tested"){ + THEN("is_subscription value is true for dynamic_subscription"){ + REQUIRE(rx::is_subscription::value); + } + THEN("is_subscription value is true for static_subscription"){ + REQUIRE(rx::is_subscription::value); + } + THEN("is_subscription value is true for subscription"){ + REQUIRE(rx::is_subscription::value); + } + THEN("is_subscription value is true for composite_subscription"){ + REQUIRE(rx::is_subscription::value); + } + } + } +} + +SCENARIO("non-subscription traits", "[subscription][traits]"){ + GIVEN("given some non-subscription types"){ + auto l = [](){}; + int i = 0; + void* v = nullptr; + WHEN("tested"){ + THEN("is_subscription value is false for lambda"){ + REQUIRE(!rx::is_subscription::value); + } + THEN("is_subscription value is false for int"){ + REQUIRE(!rx::is_subscription::value); + } + THEN("is_subscription value is false for void*"){ + REQUIRE(!rx::is_subscription::value); + } + THEN("is_subscription value is false for void"){ + REQUIRE(!rx::is_subscription::value); + } + } + } +} + +SCENARIO("subscription static", "[subscription]"){ + GIVEN("given a subscription"){ + int i=0; + auto s = rx::make_subscription([&i](){++i;}); + WHEN("not used"){ + THEN("is subscribed"){ + REQUIRE(s.is_subscribed()); + } + THEN("i is 0"){ + REQUIRE(i == 0); + } + } + WHEN("used"){ + THEN("is not subscribed when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("is not subscribed when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("i is 1 when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(i == 1); + } + THEN("i is 1 when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(i == 1); + } + } + } +} + +SCENARIO("subscription dynamic", "[subscription]"){ + GIVEN("given a subscription"){ + int i=0; + auto s = rx::make_subscription(rx::dynamic_subscription([&i](){++i;})); + WHEN("not used"){ + THEN("is subscribed"){ + REQUIRE(s.is_subscribed()); + } + THEN("i is 0"){ + REQUIRE(i == 0); + } + } + WHEN("used"){ + THEN("is not subscribed when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("is not subscribed when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("i is 1 when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(i == 1); + } + THEN("i is 1 when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(i == 1); + } + } + } +} + +SCENARIO("subscription empty", "[subscription]"){ + GIVEN("given an empty subscription"){ + auto s = rx::make_subscription(); + WHEN("not used"){ + THEN("is not subscribed"){ + REQUIRE(!s.is_subscribed()); + } + } + WHEN("used"){ + THEN("is not subscribed when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("is not subscribed when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + } + } +} + +SCENARIO("subscription composite", "[subscription]"){ + GIVEN("given a subscription"){ + int i=0; + rx::composite_subscription s; + s.add(rx::make_subscription()); + s.add(rx::make_subscription([&i](){++i;})); + s.add(rx::make_subscription(rx::dynamic_subscription([&i](){++i;}))); + WHEN("not used"){ + THEN("is subscribed"){ + REQUIRE(s.is_subscribed()); + } + THEN("i is 0"){ + REQUIRE(i == 0); + } + } + WHEN("used"){ + THEN("is not subscribed when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("is not subscribed when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(!s.is_subscribed()); + } + THEN("i is 2 when unsubscribed once"){ + s.unsubscribe(); + REQUIRE(i == 2); + } + THEN("i is 2 when unsubscribed twice"){ + s.unsubscribe(); + s.unsubscribe(); + REQUIRE(i == 2); + } + } + } +} + diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index bd4e4b6..ba23eb9 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -28,6 +28,8 @@ set(TEST_SOURCES ${TEST_DIR}/operators/SelectMany.cpp ${TEST_DIR}/operators/Where.cpp ${TEST_DIR}/operators/Publish.cpp + ${TEST_DIR}/v2/subscriptions/observer.cpp + ${TEST_DIR}/v2/subscriptions/subscription.cpp ) add_executable(rxcpp_test ${TEST_SOURCES}) -- GitLab From 40b07847443d13770b1d340ed9377f5bf66a9350 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 30 Jan 2014 21:36:58 -0800 Subject: [PATCH 178/782] added filter and range observables --- Rx/CPP/src/rxcpp/rx.hpp | 241 +++++++++++++++++++++------- Rx/CPP/test/v2/operators/filter.cpp | 33 ++++ projects/CMake/CMakeLists.txt | 1 + 3 files changed, 215 insertions(+), 60 deletions(-) create mode 100644 Rx/CPP/test/v2/operators/filter.cpp diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index c9a8157..938fefd 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -21,7 +21,7 @@ namespace rxcpp { class is_subscription { template - static typename C::subscription_tag check(int); + static typename C::subscription_tag check(int); template static void check(...); public: @@ -32,7 +32,7 @@ namespace rxcpp { { typedef std::function unsubscribe_call_type; unsubscribe_call_type unsubscribe_call; - dynamic_subscription() + dynamic_subscription() { } public: @@ -50,7 +50,7 @@ namespace rxcpp { i.unsubscribe();}) { } - dynamic_subscription(unsubscribe_call_type s) + dynamic_subscription(unsubscribe_call_type s) : unsubscribe_call(std::move(s)) { } @@ -64,7 +64,7 @@ namespace rxcpp { { typedef Unsubscribe unsubscribe_call_type; unsubscribe_call_type unsubscribe_call; - static_subscription() + static_subscription() { } public: @@ -76,7 +76,7 @@ namespace rxcpp { : unsubscribe_call(std::move(o.unsubscribe_call)) { } - static_subscription(unsubscribe_call_type s) + static_subscription(unsubscribe_call_type s) : unsubscribe_call(std::move(s)) { } @@ -120,19 +120,19 @@ namespace rxcpp { void unsubscribe() const { } }; - inline auto make_subscription() + inline auto make_subscription() -> subscription { return subscription(); } template - auto make_subscription(I i) - -> typename std::enable_if::value, + auto make_subscription(I i) + -> typename std::enable_if::value, subscription>::type { return subscription(std::move(i)); } template - auto make_subscription(Unsubscribe u) - -> typename std::enable_if::value, + auto make_subscription(Unsubscribe u) + -> typename std::enable_if::value, subscription< static_subscription>>::type { return subscription< static_subscription>( static_subscription(std::move(u))); @@ -279,7 +279,7 @@ namespace rxcpp { struct observer_base : public observer_root { private: - subscription_type s; + mutable subscription_type s; observer_base(); public: @@ -303,16 +303,16 @@ namespace rxcpp { using std::swap; swap(s, o.s); } - bool is_subscribed() { + bool is_subscribed() const { return s.is_subscribed(); } - weak_subscription add(dynamic_subscription ds) { + weak_subscription add(dynamic_subscription ds) const { return s.add(std::move(ds)); } - void remove(weak_subscription ws) { + void remove(weak_subscription ws) const { s.remove(ws); } - void unsubscribe() { + void unsubscribe() const { s.unsubscribe(); } }; @@ -321,23 +321,23 @@ namespace rxcpp { { void swap(observer_base&) { } - bool is_subscribed() { + bool is_subscribed() const { return false; } - weak_subscription add(dynamic_subscription ds) { + weak_subscription add(dynamic_subscription ds) const { ds.unsubscribe(); return weak_subscription(); } - void remove(weak_subscription) { + void remove(weak_subscription) const { } - void unsubscribe() { + void unsubscribe() const { } }; template class is_observer { template - static typename C::observer_tag check(int); + static typename C::observer_tag check(int); template static void check(...); public: @@ -347,11 +347,11 @@ namespace rxcpp { namespace detail { struct OnErrorEmpty { - void operator()(std::exception_ptr&&){} + void operator()(std::exception_ptr) const {} }; struct OnCompletedEmpty { - void operator()(){} + void operator()() const {} }; } @@ -412,17 +412,17 @@ namespace detail { swap(oncompleted, o.oncompleted); } - void on_next(T t) { + void on_next(T t) const { if (onnext) { onnext(std::move(t)); } } - void on_error(std::exception_ptr e) { + void on_error(std::exception_ptr e) const { if (onerror) { onerror(e); } } - void on_completed() { + void on_completed() const { if (oncompleted) { oncompleted(); } @@ -486,13 +486,13 @@ namespace detail { swap(oncompleted, o.oncompleted); } - void on_next(T t) { + void on_next(T t) const { onnext(std::move(t)); } - void on_error(std::exception_ptr e) { + void on_error(std::exception_ptr e) const { onerror(e); } - void on_completed() { + void on_completed() const { oncompleted(); } }; @@ -505,40 +505,40 @@ namespace detail { inner_t; inner_t inner; public: - ~observer() + ~observer() { } observer(inner_t inner) : inner(std::move(inner)) { } - void on_next(T t) { + void on_next(T t) const { if (is_subscribed()) { inner.on_next(std::move(t)); } } - void on_error(std::exception_ptr e) { + void on_error(std::exception_ptr e) const { if (is_subscribed()) { inner.on_error(e); } unsubscribe(); } - void on_completed() { + void on_completed() const { if (is_subscribed()) { inner.on_completed(); } unsubscribe(); } - bool is_subscribed() { + bool is_subscribed() const { return inner.is_subscribed(); } - weak_subscription add(dynamic_subscription ds) { + weak_subscription add(dynamic_subscription ds) const { return inner.add(std::move(ds)); } - void remove(weak_subscription ws) { + void remove(weak_subscription ws) const { inner.remove(ws); } - void unsubscribe() { + void unsubscribe() const { inner.unsubscribe(); } }; @@ -549,11 +549,11 @@ namespace detail { observer() { } - void on_next(T&&) { + void on_next(T&&) const { } - void on_error(std::exception_ptr) { + void on_error(std::exception_ptr) const { } - void on_completed() { + void on_completed() const { } }; template @@ -585,40 +585,161 @@ namespace detail { } template auto make_observer(OnNext n) - -> typename std::enable_if::value, + -> typename std::enable_if::value, observer>>::type { return observer>( static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); } -#if 0 - template - class observable - { - public: - ~observable(); +#if 1 + template + class observable; - observable(const observable& o) - : onsubscribe(o.onsubscribe) + namespace operators + { + struct tag_operator {}; + template + struct operator_base { - } - observable(observable&& o) - : onsubscribe(std::move(o.onsubscribe)) + typedef T value_type; + typedef tag_operator operator_tag; + }; + template + class is_operator + { + template + static typename C::operator_tag check(int); + template + static void check(...); + public: + static const bool value = std::is_same(0)), tag_operator>::value; + }; + + template + struct filter : public operator_base + { + Observable source; + Predicate test; + filter(Observable o, Predicate p) + : source(std::move(o)) + , test(std::move(p)) + {} + template + void on_subscribe(observer o) { + o.add(source.subscribe(make_observer( + // on_next + [this, o](T t) { + bool filtered = false; + try { + filtered = !this->test(t); + } catch(...) { + o.on_error(std::current_exception()); + o.unsubscribe(); + } + if (!filtered) { + o.on_next(std::move(t)); + } + }, + // on_error + [o](std::exception_ptr e) { + o.on_error(e); + }, + // on_completed + [o]() { + o.on_completed(); + } + ))); + } + }; + + } + namespace rxo=operators; + + namespace sources + { + struct tag_source {}; + template + struct source_base { - } + typedef T value_type; + typedef tag_source source_tag; + }; + template + class is_source + { + template + static typename C::source_tag check(int); + template + static void check(...); + public: + static const bool value = std::is_same(0)), tag_source>::value; + }; - observable(on_subscribe_t os) - : onsubscribe(std::move(os)) + template + struct range : public source_base { + struct state_type + { + T next; + size_t remaining; + ptrdiff_t step; + }; + state_type init; + range(T b, size_t c, ptrdiff_t s) + { + init.next = b; + init.remaining = c; + init.step = s; + } + template + void on_subscribe(observer o) { + auto state = std::make_shared(init); + auto s = make_subscription(); + for (;state->remaining != 0; --state->remaining) { + o.on_next(state->next); + state->next = static_cast(state->step + state->next); + } + o.on_completed(); + } + }; + } + namespace rxs=sources; + + template + class observable + : public B + { + public: + static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); + + template + observable(A&&... a) + : B(std::forward(a)...) + {} + + template + auto subscribe(observer o) + -> decltype(make_subscription(o)) { + B::on_subscribe(o); + return make_subscription(o); } - static observable create(on_subscribe_t os) { - return observable(std::move(os)); + template + observable> filter(Predicate p) { + return observable>(*this, std::move(p)); } - static observable create(const subscribe_t& s) { - return observable([s](observer o){ - o.add(s(o)); - }); + }; + + // observable<> has static methods to construct observable sources and adaptors. + // observable<> is not constructable + template<> + class observable + { + ~observable(); + public: + template + static observable> range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) { + return observable>(start, count, step); } }; #endif diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp new file mode 100644 index 0000000..2ff05a3 --- /dev/null +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -0,0 +1,33 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; + +#include "catch.hpp" + +namespace { +bool IsPrime(int x) +{ + if (x < 2) return false; + for (int i = 2; i <= x/2; ++i) + { + if (x % i == 0) + return false; + } + return true; +} +} + +SCENARIO("filter", "[filter][operators][traits]"){ + GIVEN("given a range of ints from 1 to 100"){ + WHEN("filtered to primes"){ + THEN("a subscription only observes primes"){ + auto s = rx::observable<>::range(1, 100, 1) + .filter(IsPrime) + .subscribe(rx::make_observer([](int t) { + const auto prime = IsPrime(t) ? t : -1; + REQUIRE( t == prime ); + })); + } + } + } +} + diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index ba23eb9..74ce562 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -30,6 +30,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/Publish.cpp ${TEST_DIR}/v2/subscriptions/observer.cpp ${TEST_DIR}/v2/subscriptions/subscription.cpp + ${TEST_DIR}/v2/operators/filter.cpp ) add_executable(rxcpp_test ${TEST_SOURCES}) -- GitLab From 0032aea34ccc6af751ddfb02f57d03f83a30ca4b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 30 Jan 2014 22:05:06 -0800 Subject: [PATCH 179/782] adds subscribe overloads to simplify the test --- Rx/CPP/src/rxcpp/rx.hpp | 21 +++++++++++++++++++-- Rx/CPP/test/v2/operators/filter.cpp | 4 ++-- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 938fefd..8f4578a 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -591,7 +591,6 @@ namespace detail { static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); } -#if 1 template class observable; @@ -724,6 +723,25 @@ namespace detail { return make_subscription(o); } + template + auto subscribe(OnNext n) + -> typename std::enable_if::value, + decltype(make_subscription(make_observer(std::move(n))))>::type { + return subscribe(make_observer(std::move(n))); + } + + template + auto subscribe(OnNext n, OnError e) + -> decltype(make_subscription(make_observer(std::move(n), std::move(e)))) { + return subscribe(make_observer(std::move(n), std::move(e))); + } + + template + auto subscribe(OnNext n, OnError e, OnCompleted c) + -> decltype(make_subscription(make_observer(std::move(n), std::move(e), std::move(c)))) { + return subscribe(make_observer(std::move(n), std::move(e), std::move(c))); + } + template observable> filter(Predicate p) { return observable>(*this, std::move(p)); @@ -742,7 +760,6 @@ namespace detail { return observable>(start, count, step); } }; -#endif } #endif diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 2ff05a3..4116a4a 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -22,10 +22,10 @@ SCENARIO("filter", "[filter][operators][traits]"){ THEN("a subscription only observes primes"){ auto s = rx::observable<>::range(1, 100, 1) .filter(IsPrime) - .subscribe(rx::make_observer([](int t) { + .subscribe([](int t) { const auto prime = IsPrime(t) ? t : -1; REQUIRE( t == prime ); - })); + }); } } } -- GitLab From 4e275e95803707e3e8106106d099bb106aeb58be Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 31 Jan 2014 17:01:36 -0800 Subject: [PATCH 180/782] add support for operator >> usage. --- Rx/CPP/src/rxcpp/rx.hpp | 295 ++++++++++++++++++---------- Rx/CPP/test/v2/operators/filter.cpp | 17 +- 2 files changed, 208 insertions(+), 104 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 8f4578a..908bdf5 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -594,115 +594,196 @@ namespace detail { template class observable; - namespace operators +namespace operators +{ + struct tag_operator {}; + template + struct operator_base { - struct tag_operator {}; - template - struct operator_base - { - typedef T value_type; - typedef tag_operator operator_tag; - }; - template - class is_operator - { - template - static typename C::operator_tag check(int); - template - static void check(...); - public: - static const bool value = std::is_same(0)), tag_operator>::value; - }; + typedef T value_type; + typedef tag_operator operator_tag; + }; + template + class is_operator + { + template + static typename C::operator_tag check(int); + template + static void check(...); + public: + static const bool value = std::is_same(0)), tag_operator>::value; + }; - template - struct filter : public operator_base - { - Observable source; - Predicate test; - filter(Observable o, Predicate p) - : source(std::move(o)) - , test(std::move(p)) - {} - template - void on_subscribe(observer o) { - o.add(source.subscribe(make_observer( - // on_next - [this, o](T t) { - bool filtered = false; - try { - filtered = !this->test(t); - } catch(...) { - o.on_error(std::current_exception()); - o.unsubscribe(); - } - if (!filtered) { - o.on_next(std::move(t)); - } - }, - // on_error - [o](std::exception_ptr e) { - o.on_error(e); - }, - // on_completed - [o]() { - o.on_completed(); - } - ))); - } - }; +namespace detail { + template + class subscribe_to_observer_factory + { + Observer observer; + public: + subscribe_to_observer_factory(Observer o) : observer(std::move(o)) {} + template + auto operator()(Observable source) + -> decltype(source.subscribe(std::move(observer))) { + return source.subscribe(std::move(observer)); + } + }; + template + class subscribe_factory + { + OnNext onnext; + OnError onerror; + OnCompleted oncompleted; + public: + subscribe_factory(OnNext n, OnError e, OnCompleted c) + : onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + {} + template + auto operator()(Observable source) + -> decltype(source.subscribe(std::move(onnext), std::move(onerror), std::move(oncompleted))) { + return source.subscribe(std::move(onnext), std::move(onerror), std::move(oncompleted)); + } + }; +} + template + auto subscribe(Observer o) + -> typename std::enable_if::value, + detail::subscribe_to_observer_factory>::type { + return detail::subscribe_to_observer_factory(std::move(o)); + } + + template + auto subscribe(OnNext n) + -> typename std::enable_if::value, + detail::subscribe_factory>::type { + return detail::subscribe_factory(std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); + } + + template + auto subscribe(OnNext n, OnError e) + -> detail::subscribe_factory { + return detail::subscribe_factory(std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); + } + template + auto subscribe(OnNext n, OnError e, OnCompleted c) + -> detail::subscribe_factory { + return detail::subscribe_factory(std::move(n), std::move(e), std::move(c)); } - namespace rxo=operators; - namespace sources +namespace detail { + + template + struct filter : public operator_base { - struct tag_source {}; - template - struct source_base + Observable source; + Predicate test; + filter(Observable o, Predicate p) + : source(std::move(o)) + , test(std::move(p)) + {} + template + void on_subscribe(observer o) { + o.add(source.subscribe(make_observer( + // on_next + [this, o](T t) { + bool filtered = false; + try { + filtered = !this->test(t); + } catch(...) { + o.on_error(std::current_exception()); + o.unsubscribe(); + } + if (!filtered) { + o.on_next(std::move(t)); + } + }, + // on_error + [o](std::exception_ptr e) { + o.on_error(e); + }, + // on_completed + [o]() { + o.on_completed(); + } + ))); + } + }; + template + class filter_factory + { + Predicate predicate; + public: + filter_factory(Predicate p) : predicate(std::move(p)) {} + template + auto operator()(Observable source) + -> observable> { + return observable>(source, std::move(predicate)); + } + }; +} + template + auto filter(Predicate p) + -> detail::filter_factory { + return detail::filter_factory(std::move(p)); + } + +} +namespace rxo=operators; + +namespace sources +{ + struct tag_source {}; + template + struct source_base + { + typedef T value_type; + typedef tag_source source_tag; + }; + template + class is_source + { + template + static typename C::source_tag check(int); + template + static void check(...); + public: + static const bool value = std::is_same(0)), tag_source>::value; + }; + +namespace detail +{ + template + struct range : public source_base + { + struct state_type { - typedef T value_type; - typedef tag_source source_tag; - }; - template - class is_source - { - template - static typename C::source_tag check(int); - template - static void check(...); - public: - static const bool value = std::is_same(0)), tag_source>::value; + T next; + size_t remaining; + ptrdiff_t step; }; - - template - struct range : public source_base + state_type init; + range(T b, size_t c, ptrdiff_t s) { - struct state_type - { - T next; - size_t remaining; - ptrdiff_t step; - }; - state_type init; - range(T b, size_t c, ptrdiff_t s) - { - init.next = b; - init.remaining = c; - init.step = s; - } - template - void on_subscribe(observer o) { - auto state = std::make_shared(init); - auto s = make_subscription(); - for (;state->remaining != 0; --state->remaining) { - o.on_next(state->next); - state->next = static_cast(state->step + state->next); - } - o.on_completed(); + init.next = b; + init.remaining = c; + init.step = s; + } + template + void on_subscribe(observer o) { + auto state = std::make_shared(init); + auto s = make_subscription(); + for (;state->remaining != 0; --state->remaining) { + o.on_next(state->next); + state->next = static_cast(state->step + state->next); } - }; - } - namespace rxs=sources; + o.on_completed(); + } + }; +} +} +namespace rxs=sources; template class observable @@ -743,8 +824,9 @@ namespace detail { } template - observable> filter(Predicate p) { - return observable>(*this, std::move(p)); + auto filter(Predicate p) + -> observable> { + return observable>(*this, std::move(p)); } }; @@ -756,10 +838,17 @@ namespace detail { ~observable(); public: template - static observable> range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) { - return observable>(start, count, step); + static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) + -> observable> { + return observable>(start, count, step); } }; + template + auto operator >> (observable source, OperatorFactory&& op) + -> decltype(op(source)){ + return op(source); + } + } #endif diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 4116a4a..7648909 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,5 +1,6 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; +namespace rxo=rxcpp::operators; #include "catch.hpp" @@ -16,7 +17,7 @@ bool IsPrime(int x) } } -SCENARIO("filter", "[filter][operators][traits]"){ +SCENARIO("filter members", "[filter][operators][traits]"){ GIVEN("given a range of ints from 1 to 100"){ WHEN("filtered to primes"){ THEN("a subscription only observes primes"){ @@ -31,3 +32,17 @@ SCENARIO("filter", "[filter][operators][traits]"){ } } +SCENARIO("filter operators", "[filter][operators][traits]"){ + GIVEN("given a range of ints from 1 to 100"){ + WHEN("filtered to primes"){ + THEN("a subscription only observes primes"){ + auto s = rx::observable<>::range(1, 100, 1) + >> rxo::filter(IsPrime) + >> rxo::subscribe([](int t) { + const auto prime = IsPrime(t) ? t : -1; + REQUIRE( t == prime ); + }); + } + } + } +} -- GitLab From d61eb6c4b362a5aca9ff6d6049ac518a87068dbe Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 31 Jan 2014 17:17:45 -0800 Subject: [PATCH 181/782] move the observable base to a member --- Rx/CPP/src/rxcpp/rx.hpp | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 908bdf5..708e1eb 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -719,7 +719,8 @@ namespace detail { template auto operator()(Observable source) -> observable> { - return observable>(source, std::move(predicate)); + return observable>( + filter(source, std::move(predicate))); } }; } @@ -785,22 +786,26 @@ namespace detail } namespace rxs=sources; - template + template class observable - : public B { + SourceOperator source_operator; public: - static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); + typedef T value_type; + + static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); - template - observable(A&&... a) - : B(std::forward(a)...) + explicit observable(const SourceOperator& o) + : source_operator(o) + {} + explicit observable(SourceOperator&& o) + : source_operator(std::move(o)) {} template auto subscribe(observer o) -> decltype(make_subscription(o)) { - B::on_subscribe(o); + source_operator.on_subscribe(o); return make_subscription(o); } @@ -825,8 +830,9 @@ namespace rxs=sources; template auto filter(Predicate p) - -> observable> { - return observable>(*this, std::move(p)); + -> observable> { + return observable>( + rxo::detail::filter(*this, std::move(p))); } }; @@ -839,13 +845,14 @@ namespace rxs=sources; public: template static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) - -> observable> { - return observable>(start, count, step); + -> observable> { + return observable>( + rxs::detail::range(start, count, step)); } }; - template - auto operator >> (observable source, OperatorFactory&& op) + template + auto operator >> (observable source, OperatorFactory&& op) -> decltype(op(source)){ return op(source); } -- GitLab From 82fc7ad05f85efcc0f180f5f3ab6fc7d8e8c94b9 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sun, 2 Feb 2014 13:49:13 -0800 Subject: [PATCH 182/782] static assert that the filter predicate is ok --- Rx/CPP/src/rxcpp/rx.hpp | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 708e1eb..fbf63e7 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -25,7 +25,7 @@ namespace rxcpp { template static void check(...); public: - static const bool value = std::is_same(0)), tag_subscription>::value; + static const bool value = std::is_convertible(0)), tag_subscription>::value; }; class dynamic_subscription : public subscription_base @@ -341,7 +341,7 @@ namespace rxcpp { template static void check(...); public: - static const bool value = std::is_same(0)), tag_observer>::value; + static const bool value = std::is_convertible(0)), tag_observer>::value; }; namespace detail { @@ -611,7 +611,7 @@ namespace operators template static void check(...); public: - static const bool value = std::is_same(0)), tag_operator>::value; + static const bool value = std::is_convertible(0)), tag_operator>::value; }; namespace detail { @@ -679,10 +679,17 @@ namespace detail { { Observable source; Predicate test; + + template + static auto check(int) -> decltype((*(CP*)nullptr)(*(CT*)nullptr)); + template + static void check(...); filter(Observable o, Predicate p) : source(std::move(o)) , test(std::move(p)) - {} + { + static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); + } template void on_subscribe(observer o) { o.add(source.subscribe(make_observer( @@ -750,7 +757,7 @@ namespace sources template static void check(...); public: - static const bool value = std::is_same(0)), tag_source>::value; + static const bool value = std::is_convertible(0)), tag_source>::value; }; namespace detail -- GitLab From d3c93a84d3360d2b53ea1e199ade9bcd219df9e4 Mon Sep 17 00:00:00 2001 From: Tobias Furuholm Date: Sat, 1 Feb 2014 14:00:07 +0100 Subject: [PATCH 183/782] builds on clang --- Rx/CPP/src/rxcpp/rx.hpp | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index fbf63e7..da3c930 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -279,6 +279,9 @@ namespace rxcpp { struct observer_base : public observer_root { private: + typedef typename observer_root::subscription_type subscription_type; + typedef typename observer_root::weak_subscription weak_subscription; + mutable subscription_type s; observer_base(); @@ -319,6 +322,8 @@ namespace rxcpp { template struct observer_base : public observer_root { + typedef typename observer_root::weak_subscription weak_subscription; + void swap(observer_base&) { } bool is_subscribed() const { @@ -373,28 +378,28 @@ namespace detail { { } dynamic_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(std::move(cs)) + : observer_base(std::move(cs)) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } dynamic_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(composite_subscription()) + : observer_base(composite_subscription()) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } dynamic_observer(const dynamic_observer& o) - : observer_base(o) + : observer_base(o) , onnext(o.onnext) , onerror(o.onerror) , oncompleted(o.oncompleted) { } dynamic_observer(dynamic_observer&& o) - : observer_base(std::move(o)) + : observer_base(std::move(o)) , onnext(std::move(o.onnext)) , onerror(std::move(o.onerror)) , oncompleted(std::move(o.oncompleted)) @@ -406,7 +411,7 @@ namespace detail { } void swap(dynamic_observer& o) { using std::swap; - observer_base::swap(o); + observer_base::swap(o); swap(onnext, o.onnext); swap(onerror, o.onerror); swap(oncompleted, o.oncompleted); @@ -447,28 +452,28 @@ namespace detail { { } static_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(std::move(cs)) + : observer_base(std::move(cs)) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } static_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(composite_subscription()) + : observer_base(composite_subscription()) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } static_observer(const static_observer& o) - : observer_base(o) + : observer_base(o) , onnext(o.onnext) , onerror(o.onerror) , oncompleted(o.oncompleted) { } static_observer(static_observer&& o) - : observer_base(std::move(o)) + : observer_base(std::move(o)) , onnext(std::move(o.onnext)) , onerror(std::move(o.onerror)) , oncompleted(std::move(o.oncompleted)) @@ -480,7 +485,7 @@ namespace detail { } void swap(static_observer& o) { using std::swap; - observer_base::swap(o); + observer_base::swap(o); swap(onnext, o.onnext); swap(onerror, o.onerror); swap(oncompleted, o.oncompleted); @@ -500,8 +505,9 @@ namespace detail { template class observer : public observer_root { - typedef - typename std::conditional::value, I, dynamic_observer>::type + typedef typename observer_root::weak_subscription weak_subscription; + typedef typename std::conditional::value, I, dynamic_observer>::type + inner_t; inner_t inner; public: -- GitLab From d7c47b2934c5625b51d2be933103cb211ef1ec76 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 5 Feb 2014 21:00:21 -0800 Subject: [PATCH 184/782] modified furuholm's helpful changes for clang I did not want the private typedefs to hide the public ones in root. The compiler needed a dependent name so I gave it a typedefs for this_type and base_type where needed and used those to make the inherited typedef references dependent name lookups. I have found that using fixed names like this_type and base_type make it easier to move and copy code around. --- Rx/CPP/src/rxcpp/rx.hpp | 39 +++++++++++++++++++++------------------ 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index da3c930..3cc8232 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -279,14 +279,13 @@ namespace rxcpp { struct observer_base : public observer_root { private: - typedef typename observer_root::subscription_type subscription_type; - typedef typename observer_root::weak_subscription weak_subscription; + typedef observer_base this_type; - mutable subscription_type s; + mutable typename this_type::subscription_type s; observer_base(); public: - observer_base(subscription_type s) + observer_base(typename this_type::subscription_type s) : s(std::move(s)) { } @@ -309,10 +308,10 @@ namespace rxcpp { bool is_subscribed() const { return s.is_subscribed(); } - weak_subscription add(dynamic_subscription ds) const { + typename this_type::weak_subscription add(dynamic_subscription ds) const { return s.add(std::move(ds)); } - void remove(weak_subscription ws) const { + void remove(typename this_type::weak_subscription ws) const { s.remove(ws); } void unsubscribe() const { @@ -322,18 +321,20 @@ namespace rxcpp { template struct observer_base : public observer_root { - typedef typename observer_root::weak_subscription weak_subscription; + private: + typedef observer_base this_type; + public: void swap(observer_base&) { } bool is_subscribed() const { return false; } - weak_subscription add(dynamic_subscription ds) const { + typename this_type::weak_subscription add(dynamic_subscription ds) const { ds.unsubscribe(); - return weak_subscription(); + return typename this_type::weak_subscription(); } - void remove(weak_subscription) const { + void remove(typename this_type::weak_subscription) const { } void unsubscribe() const { } @@ -369,6 +370,8 @@ namespace detail { typedef std::function on_completed_t; private: + typedef observer_base base_type; + on_next_t onnext; on_error_t onerror; on_completed_t oncompleted; @@ -378,28 +381,28 @@ namespace detail { { } dynamic_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(std::move(cs)) + : base_type(std::move(cs)) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } dynamic_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(composite_subscription()) + : base_type(composite_subscription()) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } dynamic_observer(const dynamic_observer& o) - : observer_base(o) + : base_type(o) , onnext(o.onnext) , onerror(o.onerror) , oncompleted(o.oncompleted) { } dynamic_observer(dynamic_observer&& o) - : observer_base(std::move(o)) + : base_type(std::move(o)) , onnext(std::move(o.onnext)) , onerror(std::move(o.onerror)) , oncompleted(std::move(o.oncompleted)) @@ -505,9 +508,9 @@ namespace detail { template class observer : public observer_root { - typedef typename observer_root::weak_subscription weak_subscription; + typedef observer this_type; typedef typename std::conditional::value, I, dynamic_observer>::type - + inner_t; inner_t inner; public: @@ -538,10 +541,10 @@ namespace detail { bool is_subscribed() const { return inner.is_subscribed(); } - weak_subscription add(dynamic_subscription ds) const { + typename this_type::weak_subscription add(dynamic_subscription ds) const { return inner.add(std::move(ds)); } - void remove(weak_subscription ws) const { + void remove(typename this_type::weak_subscription ws) const { inner.remove(ws); } void unsubscribe() const { -- GitLab From 9cfe6e2caa0ea44acd884609701013277550559a Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 6 Feb 2014 10:58:01 -0800 Subject: [PATCH 185/782] refactor into multiple headers --- Rx/CPP/src/rxcpp/operators/rx-filter.hpp | 86 ++ Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp | 81 ++ Rx/CPP/src/rxcpp/rx-includes.hpp | 100 +++ Rx/CPP/src/rxcpp/rx-observer.hpp | 349 ++++++++ Rx/CPP/src/rxcpp/rx-operators.hpp | 46 + Rx/CPP/src/rxcpp/rx-sources.hpp | 40 + Rx/CPP/src/rxcpp/rx-subscription.hpp | 266 ++++++ Rx/CPP/src/rxcpp/rx.hpp | 891 ++------------------ Rx/CPP/src/rxcpp/sources/rx-range.hpp | 57 ++ Rx/CPP/test/v2/operators/filter.cpp | 3 +- 10 files changed, 1080 insertions(+), 839 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/operators/rx-filter.hpp create mode 100644 Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-includes.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-observer.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-operators.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-sources.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-subscription.hpp create mode 100644 Rx/CPP/src/rxcpp/sources/rx-range.hpp diff --git a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp new file mode 100644 index 0000000..09b11eb --- /dev/null +++ b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp @@ -0,0 +1,86 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_FILTER_HPP) +#define RXCPP_OPERATORS_RX_FILTER_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct filter : public operator_base +{ + Observable source; + Predicate test; + + template + static auto check(int) -> decltype((*(CP*)nullptr)(*(CT*)nullptr)); + template + static void check(...); + filter(Observable o, Predicate p) + : source(std::move(o)) + , test(std::move(p)) + { + static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); + } + template + void on_subscribe(observer o) { + o.add(source.subscribe(make_observer( + // on_next + [this, o](T t) { + bool filtered = false; + try { + filtered = !this->test(t); + } catch(...) { + o.on_error(std::current_exception()); + o.unsubscribe(); + } + if (!filtered) { + o.on_next(std::move(t)); + } + }, + // on_error + [o](std::exception_ptr e) { + o.on_error(e); + }, + // on_completed + [o]() { + o.on_completed(); + } + ))); + } +}; + +template +class filter_factory +{ + Predicate predicate; +public: + filter_factory(Predicate p) : predicate(std::move(p)) {} + template + auto operator()(Observable source) + -> observable> { + return observable>( + filter(source, std::move(predicate))); + } +}; + +} + +template +auto filter(Predicate p) + -> detail::filter_factory { + return detail::filter_factory(std::move(p)); +} + +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp new file mode 100644 index 0000000..40af349 --- /dev/null +++ b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp @@ -0,0 +1,81 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_SUBSCRIBE_HPP) +#define RXCPP_OPERATORS_RX_SUBSCRIBE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +class subscribe_to_observer_factory +{ + Observer observer; +public: + subscribe_to_observer_factory(Observer o) : observer(std::move(o)) {} + template + auto operator()(Observable source) + -> decltype(source.subscribe(std::move(observer))) { + return source.subscribe(std::move(observer)); + } +}; +template +class subscribe_factory +{ + OnNext onnext; + OnError onerror; + OnCompleted oncompleted; +public: + subscribe_factory(OnNext n, OnError e, OnCompleted c) + : onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + {} + template + auto operator()(Observable source) + -> decltype(source.subscribe(make_observer(std::move(onnext), std::move(onerror), std::move(oncompleted)))) { + return source.subscribe(make_observer(std::move(onnext), std::move(onerror), std::move(oncompleted))); + } +}; + +} + + +template +auto subscribe(Observer o) + -> typename std::enable_if::value, + detail::subscribe_to_observer_factory>::type { + return detail::subscribe_to_observer_factory(std::move(o)); +} + +template +auto subscribe(OnNext n) + -> typename std::enable_if::value, + detail::subscribe_factory>::type { + return detail::subscribe_factory(std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); +} + +template +auto subscribe(OnNext n, OnError e) + -> detail::subscribe_factory { + return detail::subscribe_factory(std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); +} + +template +auto subscribe(OnNext n, OnError e, OnCompleted c) + -> detail::subscribe_factory { + return detail::subscribe_factory(std::move(n), std::move(e), std::move(c)); +} + + +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp new file mode 100644 index 0000000..79f57b4 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -0,0 +1,100 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_INCLUDES_HPP) +#define RXCPP_RX_INCLUDES_HPP + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// some configuration macros +#if defined(_MSC_VER) + +#if _MSC_VER > 1600 +#define RXCPP_USE_RVALUEREF 1 +#endif + +#if _MSC_VER >= 1800 +#define RXCPP_USE_VARIADIC_TEMPLATES 1 +#endif + +#if _CPPRTTI +#define RXCPP_USE_RTTI 1 +#endif + +#elif defined(__clang__) + +#if __has_feature(cxx_rvalue_references) +#define RXCPP_USE_RVALUEREF 1 +#endif +#if __has_feature(cxx_rtti) +#define RXCPP_USE_RTTI 1 +#endif +#if __has_feature(cxx_variadic_templates) +#define RXCPP_USE_VARIADIC_TEMPLATES 1 +#endif + +#endif + +#if !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) +#define RXCPP_USE_WINRT 0 +#else +#define RXCPP_USE_WINRT 1 +#endif + +#if defined(RXCPP_FORCE_USE_VARIADIC_TEMPLATES) +#undef RXCPP_USE_VARIADIC_TEMPLATES +#define RXCPP_USE_VARIADIC_TEMPLATES RXCPP_FORCE_USE_VARIADIC_TEMPLATES +#endif + +#if defined(RXCPP_FORCE_USE_RVALUEREF) +#undef RXCPP_USE_RVALUEREF +#define RXCPP_USE_RVALUEREF RXCPP_FORCE_USE_RVALUEREF +#endif + +#if defined(RXCPP_FORCE_USE_RTTI) +#undef RXCPP_USE_RTTI +#define RXCPP_USE_RTTI RXCPP_FORCE_USE_RTTI +#endif + +#if defined(RXCPP_FORCE_USE_WINRT) +#undef RXCPP_USE_WINRT +#define RXCPP_USE_WINRT RXCPP_FORCE_USE_WINRT +#endif + +#include "rx-subscription.hpp" +#include "rx-observer.hpp" +#include "rx-operators.hpp" +#include "rx-sources.hpp" + +#pragma pop_macro("min") +#pragma pop_macro("max") + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp new file mode 100644 index 0000000..59518c8 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -0,0 +1,349 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_OBSERVER_HPP) +#define RXCPP_RX_OBSERVER_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + + +struct tag_observer {}; +template +struct observer_root : public subscription_base +{ + typedef T value_type; + typedef composite_subscription subscription_type; + typedef typename subscription_type::weak_subscription weak_subscription; + typedef tag_observer observer_tag; +}; +template +struct observer_base : public observer_root +{ +private: + typedef observer_base this_type; + + mutable typename this_type::subscription_type s; + + observer_base(); +public: + observer_base(typename this_type::subscription_type s) + : s(std::move(s)) + { + } + observer_base(const observer_base& o) + : s(o.s) + { + } + observer_base(observer_base&& o) + : s(std::move(o.s)) + { + } + observer_base& operator=(observer_base o) { + swap(o); + return *this; + } + void swap(observer_base& o) { + using std::swap; + swap(s, o.s); + } + bool is_subscribed() const { + return s.is_subscribed(); + } + typename this_type::weak_subscription add(dynamic_subscription ds) const { + return s.add(std::move(ds)); + } + void remove(typename this_type::weak_subscription ws) const { + s.remove(ws); + } + void unsubscribe() const { + s.unsubscribe(); + } +}; +template +struct observer_base : public observer_root +{ +private: + typedef observer_base this_type; + +public: + void swap(observer_base&) { + } + bool is_subscribed() const { + return false; + } + typename this_type::weak_subscription add(dynamic_subscription ds) const { + ds.unsubscribe(); + return typename this_type::weak_subscription(); + } + void remove(typename this_type::weak_subscription) const { + } + void unsubscribe() const { + } +}; +template +class is_observer +{ + template + static typename C::observer_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_observer>::value; +}; + +namespace detail { +struct OnErrorEmpty +{ + void operator()(std::exception_ptr) const {} +}; +struct OnCompletedEmpty +{ + void operator()() const {} +}; +} + +template +class dynamic_observer : public observer_base +{ +public: + typedef std::function on_next_t; + typedef std::function on_error_t; + typedef std::function on_completed_t; + +private: + typedef observer_base base_type; + + on_next_t onnext; + on_error_t onerror; + on_completed_t oncompleted; + +public: + dynamic_observer() + { + } + dynamic_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) + : base_type(std::move(cs)) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + dynamic_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) + : base_type(composite_subscription()) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + dynamic_observer(const dynamic_observer& o) + : base_type(o) + , onnext(o.onnext) + , onerror(o.onerror) + , oncompleted(o.oncompleted) + { + } + dynamic_observer(dynamic_observer&& o) + : base_type(std::move(o)) + , onnext(std::move(o.onnext)) + , onerror(std::move(o.onerror)) + , oncompleted(std::move(o.oncompleted)) + { + } + dynamic_observer& operator=(dynamic_observer o) { + swap(o); + return *this; + } + void swap(dynamic_observer& o) { + using std::swap; + observer_base::swap(o); + swap(onnext, o.onnext); + swap(onerror, o.onerror); + swap(oncompleted, o.oncompleted); + } + + void on_next(T t) const { + if (onnext) { + onnext(std::move(t)); + } + } + void on_error(std::exception_ptr e) const { + if (onerror) { + onerror(e); + } + } + void on_completed() const { + if (oncompleted) { + oncompleted(); + } + } +}; + +template +class static_observer : public observer_base +{ +public: + typedef OnNext on_next_t; + typedef OnError on_error_t; + typedef OnCompleted on_completed_t; + +private: + on_next_t onnext; + on_error_t onerror; + on_completed_t oncompleted; + +public: + static_observer() + { + } + static_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) + : observer_base(std::move(cs)) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + static_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) + : observer_base(composite_subscription()) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + { + } + static_observer(const static_observer& o) + : observer_base(o) + , onnext(o.onnext) + , onerror(o.onerror) + , oncompleted(o.oncompleted) + { + } + static_observer(static_observer&& o) + : observer_base(std::move(o)) + , onnext(std::move(o.onnext)) + , onerror(std::move(o.onerror)) + , oncompleted(std::move(o.oncompleted)) + { + } + static_observer& operator=(static_observer o) { + swap(o); + return *this; + } + void swap(static_observer& o) { + using std::swap; + observer_base::swap(o); + swap(onnext, o.onnext); + swap(onerror, o.onerror); + swap(oncompleted, o.oncompleted); + } + + void on_next(T t) const { + onnext(std::move(t)); + } + void on_error(std::exception_ptr e) const { + onerror(e); + } + void on_completed() const { + oncompleted(); + } +}; + +template +class observer : public observer_root +{ + typedef observer this_type; + typedef typename std::conditional::value, I, dynamic_observer>::type + + inner_t; + inner_t inner; +public: + ~observer() + { + } + observer(inner_t inner) + : inner(std::move(inner)) + { + } + void on_next(T t) const { + if (is_subscribed()) { + inner.on_next(std::move(t)); + } + } + void on_error(std::exception_ptr e) const { + if (is_subscribed()) { + inner.on_error(e); + } + unsubscribe(); + } + void on_completed() const { + if (is_subscribed()) { + inner.on_completed(); + } + unsubscribe(); + } + bool is_subscribed() const { + return inner.is_subscribed(); + } + typename this_type::weak_subscription add(dynamic_subscription ds) const { + return inner.add(std::move(ds)); + } + void remove(typename this_type::weak_subscription ws) const { + inner.remove(ws); + } + void unsubscribe() const { + inner.unsubscribe(); + } +}; +template +class observer : public observer_base +{ +public: + observer() + { + } + void on_next(T&&) const { + } + void on_error(std::exception_ptr) const { + } + void on_completed() const { + } +}; +template +auto make_observer() + -> observer { + return observer(); +} +template +auto make_observer(I i) + -> typename std::enable_if::value, observer>::type { + return observer(std::move(i)); +} +template +auto make_observer(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) + -> observer> { + return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); +} +template +auto make_observer(OnNext n, OnError e, OnCompleted c) + -> observer> { + return observer>( + static_observer(std::move(n), std::move(e), std::move(c))); +} +template +auto make_observer(OnNext n, OnError e) + -> observer> { + return observer>( + static_observer(std::move(n), std::move(e), detail::OnCompletedEmpty())); +} +template +auto make_observer(OnNext n) + -> typename std::enable_if::value, + observer>>::type { + return observer>( + static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-operators.hpp b/Rx/CPP/src/rxcpp/rx-operators.hpp new file mode 100644 index 0000000..551a0ab --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-operators.hpp @@ -0,0 +1,46 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_OPERATORS_HPP) +#define RXCPP_RX_OPERATORS_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + + +template +class observable; + + +namespace operators { + + +struct tag_operator {}; +template +struct operator_base +{ + typedef T value_type; + typedef tag_operator operator_tag; +}; +template +class is_operator +{ + template + static typename C::operator_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_operator>::value; +}; + +} +namespace rxo=operators; + +} + +#include "operators/rx-subscribe.hpp" +#include "operators/rx-filter.hpp" + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp new file mode 100644 index 0000000..77ae0b8 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -0,0 +1,40 @@ + +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SOURCES_HPP) +#define RXCPP_RX_SOURCES_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +struct tag_source {}; +template +struct source_base +{ + typedef T value_type; + typedef tag_source source_tag; +}; +template +class is_source +{ + template + static typename C::source_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_source>::value; +}; + +} +namespace rxs=sources; + +} + +#include "sources/rx-range.hpp" + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/rx-subscription.hpp b/Rx/CPP/src/rxcpp/rx-subscription.hpp new file mode 100644 index 0000000..7b5219b --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-subscription.hpp @@ -0,0 +1,266 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SUBSCRIPTION_HPP) +#define RXCPP_RX_SUBSCRIPTION_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + + +struct tag_subscription {}; +struct subscription_base {typedef tag_subscription subscription_tag;}; +template +class is_subscription +{ + template + static typename C::subscription_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_subscription>::value; +}; + +class dynamic_subscription : public subscription_base +{ + typedef std::function unsubscribe_call_type; + unsubscribe_call_type unsubscribe_call; + dynamic_subscription() + { + } +public: + dynamic_subscription(const dynamic_subscription& o) + : unsubscribe_call(o.unsubscribe_call) + { + } + dynamic_subscription(dynamic_subscription&& o) + : unsubscribe_call(std::move(o.unsubscribe_call)) + { + } + template + dynamic_subscription(I i, typename std::enable_if::value && !std::is_same::value, void**>::type selector = nullptr) + : unsubscribe_call([i](){ + i.unsubscribe();}) + { + } + dynamic_subscription(unsubscribe_call_type s) + : unsubscribe_call(std::move(s)) + { + } + void unsubscribe() const { + unsubscribe_call(); + } +}; + +template +class static_subscription : public subscription_base +{ + typedef Unsubscribe unsubscribe_call_type; + unsubscribe_call_type unsubscribe_call; + static_subscription() + { + } +public: + static_subscription(const static_subscription& o) + : unsubscribe_call(o.unsubscribe_call) + { + } + static_subscription(static_subscription&& o) + : unsubscribe_call(std::move(o.unsubscribe_call)) + { + } + static_subscription(unsubscribe_call_type s) + : unsubscribe_call(std::move(s)) + { + } + void unsubscribe() const { + unsubscribe_call(); + } +}; + +template +class subscription : public subscription_base +{ + typedef I inner_t; + inner_t inner; + mutable bool issubscribed; +public: + subscription(inner_t inner) + : inner(std::move(inner)) + , issubscribed(true) + { + } + bool is_subscribed() const { + return issubscribed; + } + void unsubscribe() const { + if (issubscribed) { + inner.unsubscribe(); + } + issubscribed = false; + } +}; +template<> +class subscription : public subscription_base +{ +public: + subscription() + { + } + bool is_subscribed() const { + return false; + } + void unsubscribe() const { + } +}; +inline auto make_subscription() + -> subscription { + return subscription(); +} +template +auto make_subscription(I i) + -> typename std::enable_if::value, + subscription>::type { + return subscription(std::move(i)); +} +template +auto make_subscription(Unsubscribe u) + -> typename std::enable_if::value, + subscription< static_subscription>>::type { + return subscription< static_subscription>( + static_subscription(std::move(u))); +} + +class composite_subscription : public subscription_base +{ +public: + typedef std::shared_ptr shared_subscription; + typedef std::weak_ptr weak_subscription; +private: + struct state_t + { + std::vector subscriptions; + std::mutex lock; + bool issubscribed; + + state_t() + : issubscribed(true) + { + } + + bool is_subscribed() { + return issubscribed; + } + + weak_subscription add(dynamic_subscription s) { + return add(std::make_shared(std::move(s))); + } + + weak_subscription add(shared_subscription s) { + std::unique_lock guard(lock); + + if (!issubscribed) { + s->unsubscribe(); + } else { + auto end = std::end(subscriptions); + auto it = std::find(std::begin(subscriptions), end, s); + if (it == end) + { + subscriptions.emplace_back(std::move(s)); + } + } + return s; + } + + void remove(weak_subscription w) { + std::unique_lock guard(lock); + + auto s = w.lock(); + if (s) + { + auto end = std::end(subscriptions); + auto it = std::find(std::begin(subscriptions), end, s); + if (it != end) + { + subscriptions.erase(it); + } + } + } + + void clear() { + std::unique_lock guard(lock); + + if (issubscribed) { + std::vector v(std::move(subscriptions)); + std::for_each(v.begin(), v.end(), + [](shared_subscription& s) { + s->unsubscribe(); }); + } + } + + void unsubscribe() { + std::unique_lock guard(lock); + + if (issubscribed) { + issubscribed = false; + std::vector v(std::move(subscriptions)); + std::for_each(v.begin(), v.end(), + [](shared_subscription& s) { + s->unsubscribe(); }); + } + } + }; + + mutable std::shared_ptr state; + +public: + + composite_subscription() + : state(std::make_shared()) + { + } + composite_subscription(const composite_subscription& o) + : state(o.state) + { + } + composite_subscription(composite_subscription&& o) + : state(std::move(o.state)) + { + } + + composite_subscription& operator=(const composite_subscription& o) + { + state = o.state; + return *this; + } + composite_subscription& operator=(composite_subscription&& o) + { + state = std::move(o.state); + return *this; + } + + bool is_subscribed() const { + return state->is_subscribed(); + } + weak_subscription add(shared_subscription s) const { + return state->add(std::move(s)); + } + weak_subscription add(dynamic_subscription s) const { + return state->add(std::move(s)); + } + void remove(weak_subscription w) const { + state->remove(w); + } + void clear() const { + state->clear(); + } + void unsubscribe() const { + state->unsubscribe(); + } +}; + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 3cc8232..9ac9042 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -5,873 +5,88 @@ #if !defined(RXCPP_RX_HPP) #define RXCPP_RX_HPP -#include -#include -#include -#include -#include -#include -#include +#include "rx-includes.hpp" namespace rxcpp { - struct tag_subscription {}; - struct subscription_base {typedef tag_subscription subscription_tag;}; - template - class is_subscription - { - template - static typename C::subscription_tag check(int); - template - static void check(...); - public: - static const bool value = std::is_convertible(0)), tag_subscription>::value; - }; - - class dynamic_subscription : public subscription_base - { - typedef std::function unsubscribe_call_type; - unsubscribe_call_type unsubscribe_call; - dynamic_subscription() - { - } - public: - dynamic_subscription(const dynamic_subscription& o) - : unsubscribe_call(o.unsubscribe_call) - { - } - dynamic_subscription(dynamic_subscription&& o) - : unsubscribe_call(std::move(o.unsubscribe_call)) - { - } - template - dynamic_subscription(I i, typename std::enable_if::value && !std::is_same::value, void**>::type selector = nullptr) - : unsubscribe_call([i](){ - i.unsubscribe();}) - { - } - dynamic_subscription(unsubscribe_call_type s) - : unsubscribe_call(std::move(s)) - { - } - void unsubscribe() const { - unsubscribe_call(); - } - }; - - template - class static_subscription : public subscription_base - { - typedef Unsubscribe unsubscribe_call_type; - unsubscribe_call_type unsubscribe_call; - static_subscription() - { - } - public: - static_subscription(const static_subscription& o) - : unsubscribe_call(o.unsubscribe_call) - { - } - static_subscription(static_subscription&& o) - : unsubscribe_call(std::move(o.unsubscribe_call)) - { - } - static_subscription(unsubscribe_call_type s) - : unsubscribe_call(std::move(s)) - { - } - void unsubscribe() const { - unsubscribe_call(); - } - }; +template +class observable +{ + SourceOperator source_operator; +private: template - class subscription : public subscription_base - { - typedef I inner_t; - inner_t inner; - mutable bool issubscribed; - public: - subscription(inner_t inner) - : inner(std::move(inner)) - , issubscribed(true) - { - } - bool is_subscribed() const { - return issubscribed; - } - void unsubscribe() const { - if (issubscribed) { - inner.unsubscribe(); - } - issubscribed = false; - } - }; - template<> - class subscription : public subscription_base - { - public: - subscription() - { - } - bool is_subscribed() const { - return false; - } - void unsubscribe() const { - } - }; - inline auto make_subscription() - -> subscription { - return subscription(); - } - template - auto make_subscription(I i) - -> typename std::enable_if::value, - subscription>::type { - return subscription(std::move(i)); + auto detail_subscribe(observer o, tag_observer&&) + -> decltype(make_subscription(o)) { + source_operator.on_subscribe(o); + return make_subscription(o); } - template - auto make_subscription(Unsubscribe u) - -> typename std::enable_if::value, - subscription< static_subscription>>::type { - return subscription< static_subscription>( - static_subscription(std::move(u))); - } - - class composite_subscription : public subscription_base - { - public: - typedef std::shared_ptr shared_subscription; - typedef std::weak_ptr weak_subscription; - private: - struct state_t - { - std::vector subscriptions; - std::mutex lock; - bool issubscribed; - - state_t() - : issubscribed(true) - { - } - - bool is_subscribed() { - return issubscribed; - } - - weak_subscription add(dynamic_subscription s) { - return add(std::make_shared(std::move(s))); - } - - weak_subscription add(shared_subscription s) { - std::unique_lock guard(lock); - - if (!issubscribed) { - s->unsubscribe(); - } else { - auto end = std::end(subscriptions); - auto it = std::find(std::begin(subscriptions), end, s); - if (it == end) - { - subscriptions.emplace_back(std::move(s)); - } - } - return s; - } - - void remove(weak_subscription w) { - std::unique_lock guard(lock); - - auto s = w.lock(); - if (s) - { - auto end = std::end(subscriptions); - auto it = std::find(std::begin(subscriptions), end, s); - if (it != end) - { - subscriptions.erase(it); - } - } - } - - void clear() { - std::unique_lock guard(lock); - - if (issubscribed) { - std::vector v(std::move(subscriptions)); - std::for_each(v.begin(), v.end(), - [](shared_subscription& s) { - s->unsubscribe(); }); - } - } - - void unsubscribe() { - std::unique_lock guard(lock); - - if (issubscribed) { - issubscribed = false; - std::vector v(std::move(subscriptions)); - std::for_each(v.begin(), v.end(), - [](shared_subscription& s) { - s->unsubscribe(); }); - } - } - }; - - mutable std::shared_ptr state; - - public: - - composite_subscription() - : state(std::make_shared()) - { - } - composite_subscription(const composite_subscription& o) - : state(o.state) - { - } - composite_subscription(composite_subscription&& o) - : state(std::move(o.state)) - { - } - - composite_subscription& operator=(const composite_subscription& o) - { - state = o.state; - return *this; - } - composite_subscription& operator=(composite_subscription&& o) - { - state = std::move(o.state); - return *this; - } - - bool is_subscribed() const { - return state->is_subscribed(); - } - weak_subscription add(shared_subscription s) const { - return state->add(std::move(s)); - } - weak_subscription add(dynamic_subscription s) const { - return state->add(std::move(s)); - } - void remove(weak_subscription w) const { - state->remove(w); - } - void clear() const { - state->clear(); - } - void unsubscribe() const { - state->unsubscribe(); - } - }; - - struct tag_observer {}; - template - struct observer_root : public subscription_base - { - typedef T value_type; - typedef composite_subscription subscription_type; - typedef typename subscription_type::weak_subscription weak_subscription; - typedef tag_observer observer_tag; - }; - template - struct observer_base : public observer_root - { - private: - typedef observer_base this_type; - - mutable typename this_type::subscription_type s; - - observer_base(); - public: - observer_base(typename this_type::subscription_type s) - : s(std::move(s)) - { - } - observer_base(const observer_base& o) - : s(o.s) - { - } - observer_base(observer_base&& o) - : s(std::move(o.s)) - { - } - observer_base& operator=(observer_base o) { - swap(o); - return *this; - } - void swap(observer_base& o) { - using std::swap; - swap(s, o.s); - } - bool is_subscribed() const { - return s.is_subscribed(); - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - return s.add(std::move(ds)); - } - void remove(typename this_type::weak_subscription ws) const { - s.remove(ws); - } - void unsubscribe() const { - s.unsubscribe(); - } - }; - template - struct observer_base : public observer_root - { - private: - typedef observer_base this_type; - - public: - void swap(observer_base&) { - } - bool is_subscribed() const { - return false; - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - ds.unsubscribe(); - return typename this_type::weak_subscription(); - } - void remove(typename this_type::weak_subscription) const { - } - void unsubscribe() const { - } - }; - template - class is_observer - { - template - static typename C::observer_tag check(int); - template - static void check(...); - public: - static const bool value = std::is_convertible(0)), tag_observer>::value; - }; - -namespace detail { - struct OnErrorEmpty - { - void operator()(std::exception_ptr) const {} - }; - struct OnCompletedEmpty - { - void operator()() const {} - }; -} - - template - class dynamic_observer : public observer_base - { - public: - typedef std::function on_next_t; - typedef std::function on_error_t; - typedef std::function on_completed_t; - - private: - typedef observer_base base_type; - - on_next_t onnext; - on_error_t onerror; - on_completed_t oncompleted; - - public: - dynamic_observer() - { - } - dynamic_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : base_type(std::move(cs)) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - { - } - dynamic_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : base_type(composite_subscription()) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - { - } - dynamic_observer(const dynamic_observer& o) - : base_type(o) - , onnext(o.onnext) - , onerror(o.onerror) - , oncompleted(o.oncompleted) - { - } - dynamic_observer(dynamic_observer&& o) - : base_type(std::move(o)) - , onnext(std::move(o.onnext)) - , onerror(std::move(o.onerror)) - , oncompleted(std::move(o.oncompleted)) - { - } - dynamic_observer& operator=(dynamic_observer o) { - swap(o); - return *this; - } - void swap(dynamic_observer& o) { - using std::swap; - observer_base::swap(o); - swap(onnext, o.onnext); - swap(onerror, o.onerror); - swap(oncompleted, o.oncompleted); - } - - void on_next(T t) const { - if (onnext) { - onnext(std::move(t)); - } - } - void on_error(std::exception_ptr e) const { - if (onerror) { - onerror(e); - } - } - void on_completed() const { - if (oncompleted) { - oncompleted(); - } - } - }; - - template - class static_observer : public observer_base - { - public: - typedef OnNext on_next_t; - typedef OnError on_error_t; - typedef OnCompleted on_completed_t; - - private: - on_next_t onnext; - on_error_t onerror; - on_completed_t oncompleted; - - public: - static_observer() - { - } - static_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(std::move(cs)) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - { - } - static_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(composite_subscription()) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - { - } - static_observer(const static_observer& o) - : observer_base(o) - , onnext(o.onnext) - , onerror(o.onerror) - , oncompleted(o.oncompleted) - { - } - static_observer(static_observer&& o) - : observer_base(std::move(o)) - , onnext(std::move(o.onnext)) - , onerror(std::move(o.onerror)) - , oncompleted(std::move(o.oncompleted)) - { - } - static_observer& operator=(static_observer o) { - swap(o); - return *this; - } - void swap(static_observer& o) { - using std::swap; - observer_base::swap(o); - swap(onnext, o.onnext); - swap(onerror, o.onerror); - swap(oncompleted, o.oncompleted); - } - - void on_next(T t) const { - onnext(std::move(t)); - } - void on_error(std::exception_ptr e) const { - onerror(e); - } - void on_completed() const { - oncompleted(); - } - }; - template - class observer : public observer_root - { - typedef observer this_type; - typedef typename std::conditional::value, I, dynamic_observer>::type - - inner_t; - inner_t inner; - public: - ~observer() - { - } - observer(inner_t inner) - : inner(std::move(inner)) - { - } - void on_next(T t) const { - if (is_subscribed()) { - inner.on_next(std::move(t)); - } - } - void on_error(std::exception_ptr e) const { - if (is_subscribed()) { - inner.on_error(e); - } - unsubscribe(); - } - void on_completed() const { - if (is_subscribed()) { - inner.on_completed(); - } - unsubscribe(); - } - bool is_subscribed() const { - return inner.is_subscribed(); - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - return inner.add(std::move(ds)); - } - void remove(typename this_type::weak_subscription ws) const { - inner.remove(ws); - } - void unsubscribe() const { - inner.unsubscribe(); - } - }; - template - class observer : public observer_base - { - public: - observer() - { - } - void on_next(T&&) const { - } - void on_error(std::exception_ptr) const { - } - void on_completed() const { - } - }; - template - auto make_observer() - -> observer { - return observer(); - } - template - auto make_observer(I i) - -> typename std::enable_if::value, observer>::type { - return observer(std::move(i)); - } - template - auto make_observer(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) - -> observer> { - return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); - } - template - auto make_observer(OnNext n, OnError e, OnCompleted c) - -> observer> { - return observer>( - static_observer(std::move(n), std::move(e), std::move(c))); - } - template - auto make_observer(OnNext n, OnError e) - -> observer> { - return observer>( - static_observer(std::move(n), std::move(e), detail::OnCompletedEmpty())); - } - template - auto make_observer(OnNext n) - -> typename std::enable_if::value, - observer>>::type { - return observer>( - static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); + struct tag_onnext {}; + template + auto detail_subscribe(OnNext n, tag_onnext&&) + -> decltype(make_subscription(make_observer(std::move(n)))) { + return subscribe(make_observer(std::move(n))); } - template - class observable; +public: + typedef T value_type; -namespace operators -{ - struct tag_operator {}; - template - struct operator_base - { - typedef T value_type; - typedef tag_operator operator_tag; - }; - template - class is_operator - { - template - static typename C::operator_tag check(int); - template - static void check(...); - public: - static const bool value = std::is_convertible(0)), tag_operator>::value; - }; + static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); -namespace detail { - template - class subscribe_to_observer_factory - { - Observer observer; - public: - subscribe_to_observer_factory(Observer o) : observer(std::move(o)) {} - template - auto operator()(Observable source) - -> decltype(source.subscribe(std::move(observer))) { - return source.subscribe(std::move(observer)); - } - }; - template - class subscribe_factory - { - OnNext onnext; - OnError onerror; - OnCompleted oncompleted; - public: - subscribe_factory(OnNext n, OnError e, OnCompleted c) - : onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - {} - template - auto operator()(Observable source) - -> decltype(source.subscribe(std::move(onnext), std::move(onerror), std::move(oncompleted))) { - return source.subscribe(std::move(onnext), std::move(onerror), std::move(oncompleted)); - } - }; -} - template - auto subscribe(Observer o) - -> typename std::enable_if::value, - detail::subscribe_to_observer_factory>::type { - return detail::subscribe_to_observer_factory(std::move(o)); - } + explicit observable(const SourceOperator& o) + : source_operator(o) + {} + explicit observable(SourceOperator&& o) + : source_operator(std::move(o)) + {} - template - auto subscribe(OnNext n) - -> typename std::enable_if::value, - detail::subscribe_factory>::type { - return detail::subscribe_factory(std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); + template + auto subscribe(Arg a) + -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_onnext>::type())) { + return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_onnext>::type()); } template auto subscribe(OnNext n, OnError e) - -> detail::subscribe_factory { - return detail::subscribe_factory(std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); + -> decltype(make_subscription(make_observer(std::move(n), std::move(e)))) { + return subscribe(make_observer(std::move(n), std::move(e))); } template auto subscribe(OnNext n, OnError e, OnCompleted c) - -> detail::subscribe_factory { - return detail::subscribe_factory(std::move(n), std::move(e), std::move(c)); + -> decltype(make_subscription(make_observer(std::move(n), std::move(e), std::move(c)))) { + return subscribe(make_observer(std::move(n), std::move(e), std::move(c))); } - -namespace detail { - - template - struct filter : public operator_base - { - Observable source; - Predicate test; - - template - static auto check(int) -> decltype((*(CP*)nullptr)(*(CT*)nullptr)); - template - static void check(...); - filter(Observable o, Predicate p) - : source(std::move(o)) - , test(std::move(p)) - { - static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); - } - template - void on_subscribe(observer o) { - o.add(source.subscribe(make_observer( - // on_next - [this, o](T t) { - bool filtered = false; - try { - filtered = !this->test(t); - } catch(...) { - o.on_error(std::current_exception()); - o.unsubscribe(); - } - if (!filtered) { - o.on_next(std::move(t)); - } - }, - // on_error - [o](std::exception_ptr e) { - o.on_error(e); - }, - // on_completed - [o]() { - o.on_completed(); - } - ))); - } - }; - template - class filter_factory - { - Predicate predicate; - public: - filter_factory(Predicate p) : predicate(std::move(p)) {} - template - auto operator()(Observable source) - -> observable> { - return observable>( - filter(source, std::move(predicate))); - } - }; -} template auto filter(Predicate p) - -> detail::filter_factory { - return detail::filter_factory(std::move(p)); + -> observable> { + return observable>( + rxo::detail::filter(*this, std::move(p))); } +}; -} -namespace rxo=operators; - -namespace sources +// observable<> has static methods to construct observable sources and adaptors. +// observable<> is not constructable +template<> +class observable { - struct tag_source {}; - template - struct source_base - { - typedef T value_type; - typedef tag_source source_tag; - }; + ~observable(); +public: template - class is_source - { - template - static typename C::source_tag check(int); - template - static void check(...); - public: - static const bool value = std::is_convertible(0)), tag_source>::value; - }; + static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) + -> observable> { + return observable>( + rxs::detail::range(start, count, step)); + } +}; -namespace detail -{ - template - struct range : public source_base - { - struct state_type - { - T next; - size_t remaining; - ptrdiff_t step; - }; - state_type init; - range(T b, size_t c, ptrdiff_t s) - { - init.next = b; - init.remaining = c; - init.step = s; - } - template - void on_subscribe(observer o) { - auto state = std::make_shared(init); - auto s = make_subscription(); - for (;state->remaining != 0; --state->remaining) { - o.on_next(state->next); - state->next = static_cast(state->step + state->next); - } - o.on_completed(); - } - }; -} } -namespace rxs=sources; - - template - class observable - { - SourceOperator source_operator; - public: - typedef T value_type; - - static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); - - explicit observable(const SourceOperator& o) - : source_operator(o) - {} - explicit observable(SourceOperator&& o) - : source_operator(std::move(o)) - {} - - template - auto subscribe(observer o) - -> decltype(make_subscription(o)) { - source_operator.on_subscribe(o); - return make_subscription(o); - } - - template - auto subscribe(OnNext n) - -> typename std::enable_if::value, - decltype(make_subscription(make_observer(std::move(n))))>::type { - return subscribe(make_observer(std::move(n))); - } - - template - auto subscribe(OnNext n, OnError e) - -> decltype(make_subscription(make_observer(std::move(n), std::move(e)))) { - return subscribe(make_observer(std::move(n), std::move(e))); - } - - template - auto subscribe(OnNext n, OnError e, OnCompleted c) - -> decltype(make_subscription(make_observer(std::move(n), std::move(e), std::move(c)))) { - return subscribe(make_observer(std::move(n), std::move(e), std::move(c))); - } - - template - auto filter(Predicate p) - -> observable> { - return observable>( - rxo::detail::filter(*this, std::move(p))); - } - }; - - // observable<> has static methods to construct observable sources and adaptors. - // observable<> is not constructable - template<> - class observable - { - ~observable(); - public: - template - static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) - -> observable> { - return observable>( - rxs::detail::range(start, count, step)); - } - }; - - template - auto operator >> (observable source, OperatorFactory&& op) - -> decltype(op(source)){ - return op(source); - } +template +auto operator >> (rxcpp::observable source, OperatorFactory&& op) + -> decltype(op(source)){ + return op(source); } + #endif diff --git a/Rx/CPP/src/rxcpp/sources/rx-range.hpp b/Rx/CPP/src/rxcpp/sources/rx-range.hpp new file mode 100644 index 0000000..d4f59b0 --- /dev/null +++ b/Rx/CPP/src/rxcpp/sources/rx-range.hpp @@ -0,0 +1,57 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_RANGE_HPP) +#define RXCPP_SOURCES_RX_RANGE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct range : public source_base +{ + struct state_type + { + T next; + size_t remaining; + ptrdiff_t step; + }; + state_type init; + range(T b, size_t c, ptrdiff_t s) + { + init.next = b; + init.remaining = c; + init.step = s; + } + template + void on_subscribe(observer o) { + auto state = std::make_shared(init); + auto s = make_subscription(); + for (;state->remaining != 0; --state->remaining) { + o.on_next(state->next); + state->next = static_cast(state->step + state->next); + } + o.on_completed(); + } +}; + +} + +template +auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) + -> observable> { + return observable>( + detail::range(start, count, step)); +} + +} + +} + +#endif diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 7648909..18dbdb5 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,6 +1,7 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; #include "catch.hpp" @@ -36,7 +37,7 @@ SCENARIO("filter operators", "[filter][operators][traits]"){ GIVEN("given a range of ints from 1 to 100"){ WHEN("filtered to primes"){ THEN("a subscription only observes primes"){ - auto s = rx::observable<>::range(1, 100, 1) + auto s = rxs::range(1, 100, 1) >> rxo::filter(IsPrime) >> rxo::subscribe([](int t) { const auto prime = IsPrime(t) ? t : -1; -- GitLab From a5ca2962cf826c9b9d7fb2d554ea3e69daeffe12 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 6 Feb 2014 10:58:23 -0800 Subject: [PATCH 186/782] add rxcppv2_test target --- projects/CMake/CMakeLists.txt | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 74ce562..93404a2 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -28,11 +28,17 @@ set(TEST_SOURCES ${TEST_DIR}/operators/SelectMany.cpp ${TEST_DIR}/operators/Where.cpp ${TEST_DIR}/operators/Publish.cpp +) +add_executable(rxcpp_test ${TEST_SOURCES}) + +# define the sources of the self test +set(TEST_SOURCES + ${TEST_DIR}/test.cpp ${TEST_DIR}/v2/subscriptions/observer.cpp ${TEST_DIR}/v2/subscriptions/subscription.cpp ${TEST_DIR}/v2/operators/filter.cpp ) -add_executable(rxcpp_test ${TEST_SOURCES}) +add_executable(rxcppv2_test ${TEST_SOURCES}) # define the sources of testbench set(TESTBENCH_SOURCES @@ -42,6 +48,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # configure unit tests via CTest enable_testing() + add_test(NAME RunTests COMMAND rxcpp_test) add_test(NAME ListTests COMMAND rxcpp_test --list-tests) @@ -49,3 +56,11 @@ set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test c add_test(NAME ListTags COMMAND rxcpp_test --list-tags) set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags") + +add_test(NAME RunTestsV2 COMMAND rxcppv2_test) + +add_test(NAME ListTestsV2 COMMAND rxcppv2_test --list-tests) +set_tests_properties(ListTestsV2 PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases") + +add_test(NAME ListTagsV2 COMMAND rxcppv2_test --list-tags) +set_tests_properties(ListTagsV2 PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags") -- GitLab From 7382c56e0f3aa9f22ae4e869af625f6dd6d5945d Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 12 Feb 2014 07:24:29 -0800 Subject: [PATCH 187/782] add current_thread scheduler --- Rx/CPP/src/rxcpp/rx-includes.hpp | 4 +- Rx/CPP/src/rxcpp/rx-observer.hpp | 10 + Rx/CPP/src/rxcpp/rx-scheduler.hpp | 158 ++++++++++++ Rx/CPP/src/rxcpp/rx-sources.hpp | 2 +- Rx/CPP/src/rxcpp/rx-subscription.hpp | 2 +- Rx/CPP/src/rxcpp/rx-util.hpp | 83 +++++++ Rx/CPP/src/rxcpp/rx.hpp | 30 ++- .../src/rxcpp/schedulers/rx-currentthread.hpp | 231 ++++++++++++++++++ Rx/CPP/src/rxcpp/sources/rx-range.hpp | 28 ++- 9 files changed, 535 insertions(+), 13 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/rx-scheduler.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-util.hpp create mode 100644 Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index 79f57b4..c2b22cf 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -37,7 +37,7 @@ // some configuration macros #if defined(_MSC_VER) -#if _MSC_VER > 1600 +#if _MSC_VER > 1600 #define RXCPP_USE_RVALUEREF 1 #endif @@ -89,8 +89,10 @@ #define RXCPP_USE_WINRT RXCPP_FORCE_USE_WINRT #endif +#include "rx-util.hpp" #include "rx-subscription.hpp" #include "rx-observer.hpp" +#include "rx-scheduler.hpp" #include "rx-operators.hpp" #include "rx-sources.hpp" diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index 59518c8..b893ce3 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -267,17 +267,27 @@ public: } void on_next(T t) const { if (is_subscribed()) { + RXCPP_UNWIND(unsubscriber, [this](){ + this->unsubscribe(); + }); inner.on_next(std::move(t)); + unsubscriber.dismiss(); } } void on_error(std::exception_ptr e) const { if (is_subscribed()) { + RXCPP_UNWIND_AUTO([this](){ + this->unsubscribe(); + }); inner.on_error(e); } unsubscribe(); } void on_completed() const { if (is_subscribed()) { + RXCPP_UNWIND_AUTO([this](){ + this->unsubscribe(); + }); inner.on_completed(); } unsubscribe(); diff --git a/Rx/CPP/src/rxcpp/rx-scheduler.hpp b/Rx/CPP/src/rxcpp/rx-scheduler.hpp new file mode 100644 index 0000000..3852cb8 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-scheduler.hpp @@ -0,0 +1,158 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_HPP) +#define RXCPP_RX_SCHEDULER_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +class action_type; +typedef std::shared_ptr action; + +class scheduler_base; +typedef std::shared_ptr scheduler; + +class action_type + : public subscription_base + , public std::enable_shared_from_this +{ + typedef action_type this_type; + +public: + typedef composite_subscription subscription_type; + typedef subscription_type::weak_subscription weak_subscription; + typedef std::function function_type; + +private: + mutable this_type::subscription_type s; + function_type f; + + static action shared_empty; + +public: + action_type() + { + s.unsubscribe(); + } + + explicit action_type(function_type f) + : f(std::move(f)) + { + if (!this->f) { + s.unsubscribe(); + } + } + action_type(this_type::subscription_type s, function_type f) + : s(std::move(s)) + , f(std::move(f)) + { + if (!this->f) { + this->s.unsubscribe(); + } + } + + inline static action empty() { + return shared_empty; + } + + inline action operator()(scheduler sc) { + if (is_subscribed() && f) { + return f(this->shared_from_this(), std::move(sc)); + } + return empty(); + } + + inline bool is_subscribed() const { + return s.is_subscribed(); + } + inline this_type::weak_subscription add(dynamic_subscription ds) const { + return s.add(std::move(ds)); + } + inline void remove(this_type::weak_subscription ws) const { + s.remove(ws); + } + inline void unsubscribe() const { + s.unsubscribe(); + } +}; + +//static +RXCPP_SELECT_ANY action action_type::shared_empty = std::make_shared(); + +inline action make_action_empty() { + return action_type::empty(); +} + +inline action make_action(action_type::function_type f) { + return std::make_shared(std::move(f)); +} + +inline action make_action(action_type::subscription_type s, action_type::function_type f) { + return std::make_shared(std::move(s), std::move(f)); +} + +class scheduler_base + : public std::enable_shared_from_this +{ + typedef scheduler_base this_type; + +public: + typedef std::chrono::steady_clock clock; + + virtual ~scheduler_base() {} + + virtual clock::time_point now() = 0; + + virtual void schedule(action a) = 0; + virtual void schedule(clock::duration when, action a) = 0; + virtual void schedule(clock::time_point when, action a) = 0; + + inline void schedule(action_type::function_type f){ + return schedule(make_action(std::move(f))); + } + inline void schedule(clock::duration when, action_type::function_type f){ + return schedule(when, make_action(std::move(f))); + } + inline void schedule(clock::time_point when, action_type::function_type f){ + return schedule(when, make_action(std::move(f))); + } + inline void schedule(action_type::subscription_type s, action_type::function_type f){ + return schedule(make_action(std::move(s), std::move(f))); + } + inline void schedule(clock::duration when, action_type::subscription_type s, action_type::function_type f){ + return schedule(when, make_action(std::move(s), std::move(f))); + } + inline void schedule(clock::time_point when, action_type::subscription_type s, action_type::function_type f){ + return schedule(when, make_action(std::move(s), std::move(f))); + } +}; + +namespace detail { + +template +struct time_action +{ + time_action(TimePoint when, action a) + : when(when) + , a(std::move(a)) + { + } + TimePoint when; + action a; +}; + +} + +} +namespace rxsc=schedulers; + +} + +#include "schedulers/rx-currentthread.hpp" + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp index 77ae0b8..bec8c55 100644 --- a/Rx/CPP/src/rxcpp/rx-sources.hpp +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -37,4 +37,4 @@ namespace rxs=sources; #include "sources/rx-range.hpp" -#endif \ No newline at end of file +#endif diff --git a/Rx/CPP/src/rxcpp/rx-subscription.hpp b/Rx/CPP/src/rxcpp/rx-subscription.hpp index 7b5219b..f580dde 100644 --- a/Rx/CPP/src/rxcpp/rx-subscription.hpp +++ b/Rx/CPP/src/rxcpp/rx-subscription.hpp @@ -263,4 +263,4 @@ public: } -#endif \ No newline at end of file +#endif diff --git a/Rx/CPP/src/rxcpp/rx-util.hpp b/Rx/CPP/src/rxcpp/rx-util.hpp new file mode 100644 index 0000000..3762607 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-util.hpp @@ -0,0 +1,83 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_UTIL_HPP) +#define RXCPP_RX_UTIL_HPP + +#include "rx-includes.hpp" + +#if !defined(RXCPP_THREAD_LOCAL) +#if defined(_MSC_VER) +#define RXCPP_THREAD_LOCAL __declspec(thread) +#else +#define RXCPP_THREAD_LOCAL __thread +#endif +#endif + +#if !defined(RXCPP_SELECT_ANY) +#if defined(_MSC_VER) +#define RXCPP_SELECT_ANY __declspec(selectany) +#else +#define RXCPP_SELECT_ANY +#endif +#endif + +#define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix +#define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) + +#define RXCPP_MAKE_IDENTIFIER(Prefix) RXCPP_CONCAT_EVALUATE(Prefix, __LINE__) + +namespace rxcpp { + +namespace detail { + +template +class unwinder +{ +public: + ~unwinder() + { + if (!!function) + { + try { + (*function)(); + } catch (...) { + std::unexpected(); + } + } + } + + explicit unwinder(Function* functionArg) + : function(functionArg) + { + } + + void dismiss() + { + function = nullptr; + } + +private: + unwinder(); + unwinder(const unwinder&); + unwinder& operator=(const unwinder&); + + Function* function; +}; + +} + +} + +#define RXCPP_UNWIND(Name, Function) \ + RXCPP_UNWIND_EXPLICIT(uwfunc_ ## Name, Name, Function) + +#define RXCPP_UNWIND_AUTO(Function) \ + RXCPP_UNWIND_EXPLICIT(RXCPP_MAKE_IDENTIFIER(uwfunc_), RXCPP_MAKE_IDENTIFIER(unwind_), Function) + +#define RXCPP_UNWIND_EXPLICIT(FunctionName, UnwinderName, Function) \ + auto FunctionName = (Function); \ + rxcpp::detail::unwinder UnwinderName(std::addressof(FunctionName)) + +#endif diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 9ac9042..e7ec220 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -18,7 +18,30 @@ private: template auto detail_subscribe(observer o, tag_observer&&) -> decltype(make_subscription(o)) { - source_operator.on_subscribe(o); + + auto subscriber = [=]() { + try { + source_operator.on_subscribe(o); + } + catch(...) { + if (!o.is_subscribed()) { + throw; + } + o.on_error(std::current_exception()); + o.unsubscribe(); + } + }; + + if (rxsc::current_thread::is_schedule_required()) { + auto sc = rxsc::make_current_thread(); + sc->schedule([=](rxsc::action, rxsc::scheduler) { + subscriber(); + return rxsc::make_action_empty(); + }); + } else { + subscriber(); + } + return make_subscription(o); } @@ -58,6 +81,7 @@ public: -> decltype(make_subscription(make_observer(std::move(n), std::move(e), std::move(c)))) { return subscribe(make_observer(std::move(n), std::move(e), std::move(c))); } + template auto filter(Predicate p) -> observable> { @@ -74,10 +98,10 @@ class observable ~observable(); public: template - static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) + static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) -> observable> { return observable>( - rxs::detail::range(start, count, step)); + rxs::detail::range(start, count, step, sc)); } }; diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp new file mode 100644 index 0000000..6e82354 --- /dev/null +++ b/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp @@ -0,0 +1,231 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_CURRENT_THREAD_HPP) +#define RXCPP_RX_SCHEDULER_CURRENT_THREAD_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +namespace detail { + +struct action_queue +{ + typedef action_queue this_type; + + typedef scheduler_base::clock clock; + typedef time_action item_type; + +private: + struct compare_item_time + { + bool operator()(const item_type& lhs, const item_type& rhs) const { + return lhs.when > rhs.when; + } + }; + + typedef std::priority_queue< + item_type, + std::vector, + compare_item_time + > queue_item_time; + +public: + struct current_thread_queue_type { + scheduler sc; + queue_item_time queue; + }; + +private: + static current_thread_queue_type*& current_thread_queue() { + RXCPP_THREAD_LOCAL static current_thread_queue_type* queue; + return queue; + } + +public: + + static scheduler get_scheduler() { + return !!current_thread_queue() ? current_thread_queue()->sc : scheduler(); + } + static bool empty() { + if (!current_thread_queue()) { + abort(); + } + return current_thread_queue()->queue.empty(); + } + static queue_item_time::const_reference top() { + if (!current_thread_queue()) { + abort(); + } + return current_thread_queue()->queue.top(); + } + static void pop() { + if (!current_thread_queue()) { + abort(); + } + current_thread_queue()->queue.pop(); + } + static void push(item_type item) { + if (!current_thread_queue()) { + abort(); + } + current_thread_queue()->queue.push(std::move(item)); + } + static scheduler ensure(scheduler sc) { + if (!!current_thread_queue()) { + abort(); + } + // create and publish new queue + current_thread_queue() = new current_thread_queue_type(); + current_thread_queue()->sc = sc; + return sc; + } + static std::unique_ptr create(scheduler sc) { + std::unique_ptr result(new current_thread_queue_type()); + result->sc = std::move(sc); + return result; + } + static void set(current_thread_queue_type* queue) { + if (!!current_thread_queue()) { + abort(); + } + // publish new queue + current_thread_queue() = queue; + } + static void destroy(current_thread_queue_type* queue) { + delete queue; + } + static void destroy() { + if (!current_thread_queue()) { + abort(); + } + destroy(current_thread_queue()); + current_thread_queue() = nullptr; + } +}; + + +} + +struct current_thread : public scheduler_base +{ +private: + typedef current_thread this_type; + current_thread(const this_type&); + + typedef detail::action_queue queue; + + struct derecurser : public scheduler_base + { + private: + typedef current_thread this_type; + derecurser(const this_type&); + public: + derecurser() + { + } + virtual ~derecurser() + { + } + + virtual clock::time_point now() { + return clock::now(); + } + + virtual void schedule(action a) { + queue::push(queue::item_type(now(), std::move(a))); + } + + virtual void schedule(clock::duration when, action a) { + queue::push(queue::item_type(now() + when, std::move(a))); + } + + virtual void schedule(clock::time_point when, action a) { + queue::push(queue::item_type(when, std::move(a))); + } + }; + +public: + current_thread() + { + } + virtual ~current_thread() + { + } + + static bool is_schedule_required() { return !queue::get_scheduler(); } + + virtual clock::time_point now() { + return clock::now(); + } + + virtual void schedule(action a) { + schedule(now(), std::move(a)); + } + + virtual void schedule(clock::duration when, action a) { + schedule(now() + when, std::move(a)); + } + + virtual void schedule(clock::time_point when, action a) { + auto sc = queue::get_scheduler(); + // check ownership + if (!!sc) + { + // already has an owner - delegate + return sc->schedule(when, std::move(a)); + } + + // take ownership + + sc = queue::ensure(std::make_shared()); + RXCPP_UNWIND_AUTO([]{ + queue::destroy(); + }); + + queue::push(queue::item_type(when, std::move(a))); + + // loop until queue is empty + for ( + auto when = queue::top().when; + std::this_thread::sleep_until(when), true; + when = queue::top().when + ) + { + auto a = queue::top().a; + + queue::pop(); + + for (;;) { + a = (*a)(sc); + if (!a->is_subscribed()) { + break; + } + if (!queue::empty()) { + // take proper place in line + sc->schedule(std::move(a)); + break; + } + // tail recurse to a + } + + if (queue::empty()) { + break; + } + } + } +}; + +inline scheduler make_current_thread() { + return std::make_shared(); +} + +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/sources/rx-range.hpp b/Rx/CPP/src/rxcpp/sources/rx-range.hpp index d4f59b0..683edfa 100644 --- a/Rx/CPP/src/rxcpp/sources/rx-range.hpp +++ b/Rx/CPP/src/rxcpp/sources/rx-range.hpp @@ -21,33 +21,47 @@ struct range : public source_base T next; size_t remaining; ptrdiff_t step; + rxsc::scheduler sc; }; state_type init; - range(T b, size_t c, ptrdiff_t s) + range(T b, size_t c, ptrdiff_t s, rxsc::scheduler sc) { init.next = b; init.remaining = c; init.step = s; + init.sc = sc; } template void on_subscribe(observer o) { auto state = std::make_shared(init); - auto s = make_subscription(); - for (;state->remaining != 0; --state->remaining) { + state->sc->schedule([=](rxsc::action that, rxsc::scheduler){ + if (state->remaining == 0) { + o.on_completed(); + // o is unsubscribed + } + if (!o.is_subscribed()) { + // terminate loop + return rxsc::make_action_empty(); + } + + // send next value + --state->remaining; o.on_next(state->next); state->next = static_cast(state->step + state->next); - } - o.on_completed(); + + // tail recurse this same action to continue loop + return that; + }); } }; } template -auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1) +auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) -> observable> { return observable>( - detail::range(start, count, step)); + detail::range(start, count, step, sc)); } } -- GitLab From 87b5a5cb6bfb35483dc602358e1ca5b9cfe4d853 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 12 Feb 2014 07:41:56 -0800 Subject: [PATCH 188/782] fix clang build --- Rx/CPP/src/rxcpp/rx-util.hpp | 2 +- Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-util.hpp b/Rx/CPP/src/rxcpp/rx-util.hpp index 3762607..380d53b 100644 --- a/Rx/CPP/src/rxcpp/rx-util.hpp +++ b/Rx/CPP/src/rxcpp/rx-util.hpp @@ -19,7 +19,7 @@ #if defined(_MSC_VER) #define RXCPP_SELECT_ANY __declspec(selectany) #else -#define RXCPP_SELECT_ANY +#define RXCPP_SELECT_ANY __attribute__((weak)) #endif #endif diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp index 6e82354..c8c0082 100644 --- a/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp @@ -5,7 +5,7 @@ #if !defined(RXCPP_RX_SCHEDULER_CURRENT_THREAD_HPP) #define RXCPP_RX_SCHEDULER_CURRENT_THREAD_HPP -#include "rx-includes.hpp" +#include "../rx-includes.hpp" namespace rxcpp { -- GitLab From f56f054158ae6f9a63e51cc12ab2a56cd07e5806 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 13 Feb 2014 08:17:15 -0800 Subject: [PATCH 189/782] add notification types --- Rx/CPP/src/rxcpp/rx-includes.hpp | 1 + Rx/CPP/src/rxcpp/rx-notification.hpp | 230 +++++++++++++++++++++++++++ Rx/CPP/src/rxcpp/rx-observer.hpp | 5 + 3 files changed, 236 insertions(+) create mode 100644 Rx/CPP/src/rxcpp/rx-notification.hpp diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index c2b22cf..07f4b7f 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -92,6 +92,7 @@ #include "rx-util.hpp" #include "rx-subscription.hpp" #include "rx-observer.hpp" +#include "rx-notification.hpp" #include "rx-scheduler.hpp" #include "rx-operators.hpp" #include "rx-sources.hpp" diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/CPP/src/rxcpp/rx-notification.hpp new file mode 100644 index 0000000..f0b6aa0 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-notification.hpp @@ -0,0 +1,230 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_NOTIFICATION_HPP) +#define RXCPP_RX_NOTIFICATION_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace notifications { + +template +class recorded +{ + long t; + T v; +public: + recorded(long t, T v) + : t(t), v(v) { + } + long time() const { + return t; + } + const T& value() const { + return v; + } +}; + +template +bool operator == (recorded lhs, recorded rhs) { + return lhs.Time() == rhs.Time() && lhs.Value() == rhs.Value(); +} + +template +std::ostream& operator<< (std::ostream& out, const recorded& r) { + out << "@" << r.Time() << "-" << r.Value(); + return out; +} + +class subscription +{ + long s; + long u; + +public: + explicit inline subscription(long s) + : s(s), u(std::numeric_limits::max()) { + } + inline subscription(long s, long u) + : s(s), u(u) { + } + inline long subscribe() const { + return s; + } + inline long unsubscribe() const { + return u; + } +}; + +inline bool operator == (subscription lhs, subscription rhs) { + return lhs.subscribe() == rhs.subscribe() && lhs.unsubscribe() == rhs.unsubscribe(); +} + +inline std::ostream& operator<< (std::ostream& out, const subscription& s) { + out << s.subscribe() << "-" << s.unsubscribe(); + return out; +} + +namespace detail { + +template +struct notification_base + : public std::enable_shared_from_this> +{ + typedef observer> observer_type; + typedef std::shared_ptr> type; + + virtual ~notification_base() {} + + virtual void out(std::ostream& out) const =0; + virtual bool equals(const type& other) const = 0; + virtual void accept(const observer_type& o) const =0; +}; + +} + +template +struct notification +{ + typedef typename detail::notification_base::type type; + typedef typename detail::notification_base::observer_type observer_type; + +private: + typedef detail::notification_base base; + + struct on_next_notification : public base { + on_next_notification(T value) : value(std::move(value)) { + } + virtual void out(std::ostream& out) const { + out << "on_next( " << value << ")"; + } + virtual bool equals(const base::type& other) const { + bool result = false; + other->accept(make_observer_dynamic([this, &result](T value) { + result = this->value == value; + })); + return result; + } + virtual void accept(const base::observer_type& o) const { + if (!o) { + abort(); + } + o->on_next(value); + } + const T value; + }; + + struct on_error_notification : public base { + on_error_notification(std::exception_ptr ep) : ep(ep) { + } + virtual void out(std::ostream& out) const { + out << "on_error("; + try { + std::rethrow_exception(ep); + } catch (const std::exception& e) { + out << e.what(); + } catch (...) { + out << ""; + } + out << ")"; + } + virtual bool equals(const base::type& other) const { + bool result = false; + // not trying to compare exceptions + other->accept(make_observer_dynamic(nullptr, [&result](std::exception_ptr){ + result = true; + })); + return result; + } + virtual void accept(const base::observer_type& o) const { + if (!o) { + abort(); + } + o->on_error(ep); + } + const std::exception_ptr ep; + }; + + struct on_completed_notification : public base { + on_completed_notification() { + } + virtual void out(std::ostream& out) const { + out << "on_completed()"; + } + virtual bool equals(const base::type& other) const { + bool result = false; + other->Accept(make_observer_dynamic(nullptr, nullptr, [&result](){ + result = true; + })); + return result; + } + virtual void accept(const base::observer_type& o) const { + if (!o) { + abort(); + } + o->on_completed(); + } + }; + + struct exception_tag {}; + + template + static + type make_on_error(exception_tag&&, Exception&& e) { + std::exception_ptr ep; + try { + throw std::forward(e); + } + catch (...) { + ep = std::current_exception(); + } + return std::make_shared(ep); + } + + struct exception_ptr_tag {}; + + static + type make_on_error(exception_ptr_tag&&, std::exception_ptr ep) { + return std::make_shared(ep); + } + +public: + static + type make_on_next(T value) { + return std::make_shared(std::move(value)); + } + static + type make_on_completed() { + return std::make_shared(); + } + template + static + type make_on_error(Exception&& e) { + return make_on_error(typename std::conditional< + std::is_same::type, std::exception_ptr>::value, + exception_ptr_tag, exception_tag>::type(), + std::forward(e)); + } +}; + +template +bool operator == (const std::shared_ptr>& lhs, const std::shared_ptr>& rhs) { + if (!lhs && !rhs) {return true;} + if (!lhs || !rhs) {return false;} + return lhs->equals(rhs); +} + +template +std::ostream& operator<< (std::ostream& out, const std::shared_ptr>& n) { + n->out(out); + return out; +} + +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index b893ce3..218c668 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -353,6 +353,11 @@ auto make_observer(OnNext n) return observer>( static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); } +template +auto make_observer_dynamic(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) + -> observer> { + return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); +} } -- GitLab From 22359a8e0cc1bfc54b8469165594206cc1f721eb Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 13 Feb 2014 16:09:01 -0800 Subject: [PATCH 190/782] share one subscription instance for the whole chain --- Rx/CPP/src/rxcpp/operators/rx-filter.hpp | 5 +- Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp | 83 +++++++-- Rx/CPP/src/rxcpp/rx-observer.hpp | 165 +++++++++++++----- Rx/CPP/src/rxcpp/rx-subscription.hpp | 4 +- Rx/CPP/src/rxcpp/rx.hpp | 60 +++++-- .../src/rxcpp/schedulers/rx-currentthread.hpp | 9 +- Rx/CPP/src/rxcpp/sources/rx-range.hpp | 2 +- 7 files changed, 245 insertions(+), 83 deletions(-) diff --git a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp index 09b11eb..ffdeca6 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp @@ -31,7 +31,8 @@ struct filter : public operator_base } template void on_subscribe(observer o) { - o.add(source.subscribe(make_observer( + o.add(source.subscribe( + o.get_subscription(), // on_next [this, o](T t) { bool filtered = false; @@ -53,7 +54,7 @@ struct filter : public operator_base [o]() { o.on_completed(); } - ))); + )); } }; diff --git a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp index 40af349..e8495bf 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp @@ -43,37 +43,90 @@ public: return source.subscribe(make_observer(std::move(onnext), std::move(onerror), std::move(oncompleted))); } }; +template +class subscribe_factory_chained +{ + composite_subscription cs; + OnNext onnext; + OnError onerror; + OnCompleted oncompleted; +public: + subscribe_factory_chained(OnNext n, OnError e, OnCompleted c) + : cs(std::move(cs)) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) + {} + template + auto operator()(Observable source) + -> decltype(source.subscribe(make_observer(std::move(cs), std::move(onnext), std::move(onerror), std::move(oncompleted)))) { + return source.subscribe(make_observer(std::move(cs), std::move(onnext), std::move(onerror), std::move(oncompleted))); + } +}; + +template +auto subscribe(Observer o, tag_observer&&) + -> subscribe_to_observer_factory { + return subscribe_to_observer_factory(std::move(o)); +} +struct tag_function {}; +template +auto subscribe(OnNext n, tag_function&&) + -> subscribe_factory { + return subscribe_factory(std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); } +template +auto subscribe(OnNext n, OnError e, tag_function&&) + -> subscribe_factory { + return subscribe_factory(std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); +} -template -auto subscribe(Observer o) - -> typename std::enable_if::value, - detail::subscribe_to_observer_factory>::type { - return detail::subscribe_to_observer_factory(std::move(o)); +template +auto subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) + -> subscribe_factory { + return subscribe_factory(std::move(n), std::move(e), std::move(c)); } template -auto subscribe(OnNext n) - -> typename std::enable_if::value, - detail::subscribe_factory>::type { - return detail::subscribe_factory(std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); +auto subscribe(composite_subscription cs, OnNext n, tag_subscription&&) + -> subscribe_factory_chained { + return subscribe_factory_chained(std::move(cs), std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); } template -auto subscribe(OnNext n, OnError e) - -> detail::subscribe_factory { - return detail::subscribe_factory(std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); +auto subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) + -> subscribe_factory_chained { + return subscribe_factory_chained(std::move(cs), std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); +} + +} + +template +auto subscribe(Arg a) + -> decltype(detail::subscribe(std::move(a), typename std::conditional::value, tag_observer, detail::tag_function>::type())) { + return detail::subscribe(std::move(a), typename std::conditional::value, tag_observer, detail::tag_function>::type()); +} + +template +auto subscribe(Arg1 a1, Arg2 a2) + -> decltype(detail::subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { + return detail::subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); +} + +template +auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) + -> decltype(detail::subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { + return detail::subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); } template -auto subscribe(OnNext n, OnError e, OnCompleted c) +auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) -> detail::subscribe_factory { - return detail::subscribe_factory(std::move(n), std::move(e), std::move(c)); + return detail::subscribe_factory(std::move(cs), std::move(n), std::move(e), std::move(c)); } - } } diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index 218c668..64301c2 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -19,7 +19,7 @@ struct observer_root : public subscription_base typedef typename subscription_type::weak_subscription weak_subscription; typedef tag_observer observer_tag; }; -template +template struct observer_base : public observer_root { private: @@ -49,6 +49,9 @@ public: using std::swap; swap(s, o.s); } + typename this_type::subscription_type get_subscription() { + return s; + } bool is_subscribed() const { return s.is_subscribed(); } @@ -63,27 +66,6 @@ public: } }; template -struct observer_base : public observer_root -{ -private: - typedef observer_base this_type; - -public: - void swap(observer_base&) { - } - bool is_subscribed() const { - return false; - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - ds.unsubscribe(); - return typename this_type::weak_subscription(); - } - void remove(typename this_type::weak_subscription) const { - } - void unsubscribe() const { - } -}; -template class is_observer { template @@ -106,7 +88,7 @@ struct OnCompletedEmpty } template -class dynamic_observer : public observer_base +class dynamic_observer : public observer_base { public: typedef std::function on_next_t; @@ -114,7 +96,7 @@ public: typedef std::function on_completed_t; private: - typedef observer_base base_type; + typedef observer_base base_type; on_next_t onnext; on_error_t onerror; @@ -182,7 +164,7 @@ public: }; template -class static_observer : public observer_base +class static_observer : public observer_base { public: typedef OnNext on_next_t; @@ -199,28 +181,28 @@ public: { } static_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(std::move(cs)) + : observer_base(std::move(cs)) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } static_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(composite_subscription()) + : observer_base(composite_subscription()) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } static_observer(const static_observer& o) - : observer_base(o) + : observer_base(o) , onnext(o.onnext) , onerror(o.onerror) , oncompleted(o.oncompleted) { } static_observer(static_observer&& o) - : observer_base(std::move(o)) + : observer_base(std::move(o)) , onnext(std::move(o.onnext)) , onerror(std::move(o.onerror)) , oncompleted(std::move(o.oncompleted)) @@ -292,6 +274,9 @@ public: } unsubscribe(); } + typename this_type::subscription_type get_subscription() { + return inner.get_subscription(); + } bool is_subscribed() const { return inner.is_subscribed(); } @@ -306,8 +291,9 @@ public: } }; template -class observer : public observer_base +class observer : public observer_root { + typedef observer this_type; public: observer() { @@ -318,47 +304,134 @@ public: } void on_completed() const { } + typename this_type::subscription_type get_subscription() { + static typename this_type::subscription_type result; + result.unsubscribe(); + return result; + } + bool is_subscribed() const { + return false; + } + typename this_type::weak_subscription add(dynamic_subscription ds) const { + ds.unsubscribe(); + return typename this_type::weak_subscription(); + } + void remove(typename this_type::weak_subscription) const { + } + void unsubscribe() const { + } }; + template auto make_observer() -> observer { return observer(); } + +namespace detail { + +struct tag_require_observer {}; +template +auto make_observer(T, tag_require_observer&&) + -> observer { + static_assert(false, "this overload of make_observer requires an observer"); +} + +struct tag_require_function {}; + +template +auto make_observer(OnNext n, tag_require_function&&) + -> observer { + static_assert(false, "this overload of make_observer requires an on_next function"); +} + template -auto make_observer(I i) - -> typename std::enable_if::value, observer>::type { - return observer(std::move(i)); +auto make_observer(I i, tag_observer&&) + -> observer { + return observer(std::move(i)); } -template -auto make_observer(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) - -> observer> { - return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); + +struct tag_function {}; +template +auto make_observer(OnNext n, tag_function&&) + -> observer> { + return observer>( + static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); +} + +template +auto make_observer(OnNext n, OnError e, tag_function&&) + -> observer> { + return observer>( + static_observer(std::move(n), std::move(e), detail::OnCompletedEmpty())); } + template -auto make_observer(OnNext n, OnError e, OnCompleted c) +auto make_observer(OnNext n, OnError e, OnCompleted c, tag_function&&) -> observer> { return observer>( static_observer(std::move(n), std::move(e), std::move(c))); } + +template +auto make_observer(composite_subscription cs, OnNext n, tag_subscription&&) + -> observer> { + return observer>( + static_observer(std::move(cs), std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); +} + template -auto make_observer(OnNext n, OnError e) +auto make_observer(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) -> observer> { return observer>( - static_observer(std::move(n), std::move(e), detail::OnCompletedEmpty())); + static_observer(std::move(cs), std::move(n), std::move(e), detail::OnCompletedEmpty())); } -template -auto make_observer(OnNext n) - -> typename std::enable_if::value, - observer>>::type { - return observer>( - static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); + +} + +template +auto make_observer(Arg a) + -> decltype(detail::make_observer(std::move(a), typename std::conditional::value, tag_observer, detail::tag_require_observer>::type())) { + return detail::make_observer(std::move(a), typename std::conditional::value, tag_observer, detail::tag_require_observer>::type()); +} + +template +auto make_observer(Arg a) + -> decltype(detail::make_observer(std::move(a), typename std::conditional::value, detail::tag_require_function, detail::tag_function>::type())) { + return detail::make_observer(std::move(a), typename std::conditional::value, detail::tag_require_function, detail::tag_function>::type()); +} + +template +auto make_observer(Arg1 a1, Arg2 a2) + -> decltype(detail::make_observer(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { + return detail::make_observer(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); +} + +template +auto make_observer(Arg1 a1, Arg2 a2, Arg3 a3) + -> decltype(detail::make_observer(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { + return detail::make_observer(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); +} + +template +auto make_observer(composite_subscription cs, OnNext n, OnError e, OnCompleted c) + -> observer> { + return observer>( + static_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } + template auto make_observer_dynamic(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) -> observer> { return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); } +template +auto make_observer_dynamic(composite_subscription cs, typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) + -> observer> { + return observer>(dynamic_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); +} + } #endif diff --git a/Rx/CPP/src/rxcpp/rx-subscription.hpp b/Rx/CPP/src/rxcpp/rx-subscription.hpp index f580dde..235d5e5 100644 --- a/Rx/CPP/src/rxcpp/rx-subscription.hpp +++ b/Rx/CPP/src/rxcpp/rx-subscription.hpp @@ -139,10 +139,10 @@ public: typedef std::shared_ptr shared_subscription; typedef std::weak_ptr weak_subscription; private: - struct state_t + struct state_t : public std::enable_shared_from_this { std::vector subscriptions; - std::mutex lock; + std::recursive_mutex lock; bool issubscribed; state_t() diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index e7ec220..c46eeca 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -19,6 +19,10 @@ private: auto detail_subscribe(observer o, tag_observer&&) -> decltype(make_subscription(o)) { + if (!o.is_subscribed()) { + return make_subscription(o); + } + auto subscriber = [=]() { try { source_operator.on_subscribe(o); @@ -45,11 +49,35 @@ private: return make_subscription(o); } - struct tag_onnext {}; + struct tag_function {}; template - auto detail_subscribe(OnNext n, tag_onnext&&) - -> decltype(make_subscription(make_observer(std::move(n)))) { - return subscribe(make_observer(std::move(n))); + auto detail_subscribe(OnNext n, tag_function&&) + -> decltype(make_subscription( make_observer(std::move(n)))) { + return subscribe( make_observer(std::move(n))); + } + + template + auto detail_subscribe(OnNext n, OnError e, tag_function&&) + -> decltype(make_subscription( make_observer(std::move(n), std::move(e)))) { + return subscribe( make_observer(std::move(n), std::move(e))); + } + + template + auto detail_subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) + -> decltype(make_subscription( make_observer(std::move(n), std::move(e), std::move(c)))) { + return subscribe( make_observer(std::move(n), std::move(e), std::move(c))); + } + + template + auto detail_subscribe(composite_subscription cs, OnNext n, tag_subscription&&) + -> decltype(make_subscription( make_observer(std::move(cs), std::move(n)))) { + return subscribe( make_observer(std::move(cs), std::move(n))); + } + + template + auto detail_subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) + -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e)))) { + return subscribe( make_observer(std::move(cs), std::move(n), std::move(e))); } public: @@ -66,20 +94,26 @@ public: template auto subscribe(Arg a) - -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_onnext>::type())) { - return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_onnext>::type()); + -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type())) { + return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type()); } - template - auto subscribe(OnNext n, OnError e) - -> decltype(make_subscription(make_observer(std::move(n), std::move(e)))) { - return subscribe(make_observer(std::move(n), std::move(e))); + template + auto subscribe(Arg1 a1, Arg2 a2) + -> decltype(detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type())) { + return detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type()); + } + + template + auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) + -> decltype(detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type())) { + return detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type()); } template - auto subscribe(OnNext n, OnError e, OnCompleted c) - -> decltype(make_subscription(make_observer(std::move(n), std::move(e), std::move(c)))) { - return subscribe(make_observer(std::move(n), std::move(e), std::move(c))); + auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) + -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c)))) { + return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } template diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp index c8c0082..b3316ef 100644 --- a/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp @@ -172,6 +172,10 @@ public: } virtual void schedule(clock::time_point when, action a) { + if (!a->is_subscribed()) { + return; + } + auto sc = queue::get_scheduler(); // check ownership if (!!sc) @@ -200,11 +204,8 @@ public: queue::pop(); - for (;;) { + while (a->is_subscribed()) { a = (*a)(sc); - if (!a->is_subscribed()) { - break; - } if (!queue::empty()) { // take proper place in line sc->schedule(std::move(a)); diff --git a/Rx/CPP/src/rxcpp/sources/rx-range.hpp b/Rx/CPP/src/rxcpp/sources/rx-range.hpp index 683edfa..9a44ba9 100644 --- a/Rx/CPP/src/rxcpp/sources/rx-range.hpp +++ b/Rx/CPP/src/rxcpp/sources/rx-range.hpp @@ -34,7 +34,7 @@ struct range : public source_base template void on_subscribe(observer o) { auto state = std::make_shared(init); - state->sc->schedule([=](rxsc::action that, rxsc::scheduler){ + state->sc->schedule(o.get_subscription(), [=](rxsc::action that, rxsc::scheduler){ if (state->remaining == 0) { o.on_completed(); // o is unsubscribed -- GitLab From 3359191b8ff0e0ac855a9e28bdbfa6365e060ddf Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 13 Feb 2014 16:14:43 -0800 Subject: [PATCH 191/782] clang fixes --- Rx/CPP/src/rxcpp/rx-notification.hpp | 26 +++++++++++++------------- Rx/CPP/src/rxcpp/rx-observer.hpp | 15 ++------------- 2 files changed, 15 insertions(+), 26 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/CPP/src/rxcpp/rx-notification.hpp index f0b6aa0..f6750fb 100644 --- a/Rx/CPP/src/rxcpp/rx-notification.hpp +++ b/Rx/CPP/src/rxcpp/rx-notification.hpp @@ -17,7 +17,7 @@ class recorded long t; T v; public: - recorded(long t, T v) + recorded(long t, T v) : t(t), v(v) { } long time() const { @@ -45,10 +45,10 @@ class subscription long u; public: - explicit inline subscription(long s) + explicit inline subscription(long s) : s(s), u(std::numeric_limits::max()) { } - inline subscription(long s, long u) + inline subscription(long s, long u) : s(s), u(u) { } inline long subscribe() const { @@ -71,7 +71,7 @@ inline std::ostream& operator<< (std::ostream& out, const subscription& s) { namespace detail { template -struct notification_base +struct notification_base : public std::enable_shared_from_this> { typedef observer> observer_type; @@ -101,14 +101,14 @@ private: virtual void out(std::ostream& out) const { out << "on_next( " << value << ")"; } - virtual bool equals(const base::type& other) const { + virtual bool equals(const typename base::type& other) const { bool result = false; - other->accept(make_observer_dynamic([this, &result](T value) { + other->accept(make_observer_dynamic([this, &result](T value) { result = this->value == value; })); return result; } - virtual void accept(const base::observer_type& o) const { + virtual void accept(const typename base::observer_type& o) const { if (!o) { abort(); } @@ -131,7 +131,7 @@ private: } out << ")"; } - virtual bool equals(const base::type& other) const { + virtual bool equals(const typename base::type& other) const { bool result = false; // not trying to compare exceptions other->accept(make_observer_dynamic(nullptr, [&result](std::exception_ptr){ @@ -139,7 +139,7 @@ private: })); return result; } - virtual void accept(const base::observer_type& o) const { + virtual void accept(const typename base::observer_type& o) const { if (!o) { abort(); } @@ -154,14 +154,14 @@ private: virtual void out(std::ostream& out) const { out << "on_completed()"; } - virtual bool equals(const base::type& other) const { + virtual bool equals(const typename base::type& other) const { bool result = false; other->Accept(make_observer_dynamic(nullptr, nullptr, [&result](){ result = true; })); return result; } - virtual void accept(const base::observer_type& o) const { + virtual void accept(const typename base::observer_type& o) const { if (!o) { abort(); } @@ -204,8 +204,8 @@ public: static type make_on_error(Exception&& e) { return make_on_error(typename std::conditional< - std::is_same::type, std::exception_ptr>::value, - exception_ptr_tag, exception_tag>::type(), + std::is_same::type, std::exception_ptr>::value, + exception_ptr_tag, exception_tag>::type(), std::forward(e)); } }; diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index 64301c2..644d29b 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -140,7 +140,7 @@ public: } void swap(dynamic_observer& o) { using std::swap; - observer_base::swap(o); + observer_base::swap(o); swap(onnext, o.onnext); swap(onerror, o.onerror); swap(oncompleted, o.oncompleted); @@ -214,7 +214,7 @@ public: } void swap(static_observer& o) { using std::swap; - observer_base::swap(o); + observer_base::swap(o); swap(onnext, o.onnext); swap(onerror, o.onerror); swap(oncompleted, o.oncompleted); @@ -331,20 +331,9 @@ auto make_observer() namespace detail { struct tag_require_observer {}; -template -auto make_observer(T, tag_require_observer&&) - -> observer { - static_assert(false, "this overload of make_observer requires an observer"); -} struct tag_require_function {}; -template -auto make_observer(OnNext n, tag_require_function&&) - -> observer { - static_assert(false, "this overload of make_observer requires an on_next function"); -} - template auto make_observer(I i, tag_observer&&) -> observer { -- GitLab From 2ba9d8b7ce059b733b651cb7b38c668d60277ef6 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 13 Feb 2014 20:34:08 -0800 Subject: [PATCH 192/782] add vitual_time scheduler --- Rx/CPP/src/rxcpp/rx-notification.hpp | 1 + Rx/CPP/src/rxcpp/rx-scheduler.hpp | 17 +- .../src/rxcpp/schedulers/rx-currentthread.hpp | 21 +- .../src/rxcpp/schedulers/rx-virtualtime.hpp | 253 ++++++++++++++++++ 4 files changed, 275 insertions(+), 17 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/CPP/src/rxcpp/rx-notification.hpp index f6750fb..bf3207c 100644 --- a/Rx/CPP/src/rxcpp/rx-notification.hpp +++ b/Rx/CPP/src/rxcpp/rx-notification.hpp @@ -224,6 +224,7 @@ std::ostream& operator<< (std::ostream& out, const std::shared_ptr item_type; private: @@ -73,6 +73,9 @@ public: if (!current_thread_queue()) { abort(); } + if (!item.a->is_subscribed()) { + return; + } current_thread_queue()->queue.push(std::move(item)); } static scheduler ensure(scheduler sc) { @@ -132,19 +135,19 @@ private: { } - virtual clock::time_point now() { - return clock::now(); + virtual clock_type::time_point now() { + return clock_type::now(); } virtual void schedule(action a) { queue::push(queue::item_type(now(), std::move(a))); } - virtual void schedule(clock::duration when, action a) { + virtual void schedule(clock_type::duration when, action a) { queue::push(queue::item_type(now() + when, std::move(a))); } - virtual void schedule(clock::time_point when, action a) { + virtual void schedule(clock_type::time_point when, action a) { queue::push(queue::item_type(when, std::move(a))); } }; @@ -159,19 +162,19 @@ public: static bool is_schedule_required() { return !queue::get_scheduler(); } - virtual clock::time_point now() { - return clock::now(); + virtual clock_type::time_point now() { + return clock_type::now(); } virtual void schedule(action a) { schedule(now(), std::move(a)); } - virtual void schedule(clock::duration when, action a) { + virtual void schedule(clock_type::duration when, action a) { schedule(now() + when, std::move(a)); } - virtual void schedule(clock::time_point when, action a) { + virtual void schedule(clock_type::time_point when, action a) { if (!a->is_subscribed()) { return; } diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp new file mode 100644 index 0000000..5c20341 --- /dev/null +++ b/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -0,0 +1,253 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_VIRTUAL_TIME_HPP) +#define RXCPP_RX_SCHEDULER_VIRTUAL_TIME_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +namespace detail { + +template +struct virtual_time_base : public scheduler_base +{ +private: + typedef virtual_time_base this_type; + virtual_time_base(const virtual_time_base&); + + bool isenabled; + +public: + typedef Absolute absolute; + typedef Relative relative; + + virtual ~virtual_time_base() + { + } + +protected: + virtual_time_base() + : isenabled(false) + , clock_now(0) + { + } + explicit virtual_time_base(absolute initialClock) + : isenabled(false) + , clock_now(initialClock) + { + } + + absolute clock_now; + + typedef time_action item_type; + + virtual absolute add(absolute, relative) =0; + + virtual typename this_type::clock_type::time_point to_time_point(absolute) =0; + virtual relative to_relative(typename this_type::clock_type::duration) =0; + + virtual item_type top() =0; + virtual void pop() =0; + virtual bool empty() =0; + +public: + virtual void schedule_absolute(absolute, action) =0; + + virtual void schedule_relative(relative dueTime, action a) { + auto at = add(clock_now, dueTime); + return schedule_absolute(at, std::move(a)); + } + + bool is_enabled() {return isenabled;} + absolute clock() {return clock_now;} + + void start() + { + if (!isenabled) { + isenabled = true; + while (!empty() && isenabled) { + auto next = top(); + pop(); + if (next.a->is_subscribed()) { + if (next.when > clock_now) { + clock_now = next.when; + } + auto a = (*next.a)(shared_from_this()); + if (a.subscribed()) { + schedule(a); + } + } + else { + isenabled = false; + } + } + } + } + + void stop() + { + isenabled = false; + } + + void advance_to(absolute time) + { + if (time < clock_now) { + abort(); + } + + if (time == clock_now) { + return; + } + + if (!isenabled) { + isenabled = true; + while (!empty() && isenabled) { + auto next = top(); + pop(); + if (next.a->is_subscribed() && next.when <= time) { + if (next.when > clock_now) { + clock_now = next.when; + } + auto a = (*next.a)(shared_from_this()); + if (a.subscribed()) { + schedule(a); + } + } + else { + isenabled = false; + } + } + + clock_now = time; + } + else { + abort(); + } + } + + void advance_by(relative time) + { + auto dt = add(clock_now, time); + + if (dt < clock_now) { + abort(); + } + + if (dt == clock_now) { + return; + } + + if (!isenabled) { + advance_to(dt); + } + else { + abort(); + } + } + + void sleep(relative time) + { + auto dt = add(clock_now, time); + + if (dt < clock_now) { + abort(); + } + + clock_now = dt; + } + + virtual clock_type::time_point now() { + return to_time_point(clock_now); + } + + virtual void schedule(action a) { + schedule_absolute(clock_now, std::move(a)); + } + + virtual void schedule(clock_type::duration when, action a) { + schedule_absolute(to_relative(when), std::move(a)); + } + + virtual void schedule(clock_type::time_point when, action a) { + schedule_absolute(to_relative(when - now()), std::move(a)); + } + +}; + +} + +template +class virtual_time : public detail::virtual_time_base +{ +private: + virtual_time(const virtual_time&); + + typedef detail::virtual_time_base base; + + typedef typename base::item_type item_type; + + struct compare_item_time + { + bool operator()(const item_type& lhs, const item_type& rhs) const { + return lhs.when > rhs.when; + } + }; + + typedef std::priority_queue< + item_type, + std::vector, + compare_item_time + > queue_item_time; + + queue_item_time queue; + +public: + virtual ~virtual_time() + { + } + +protected: + virtual_time() + { + } + explicit virtual_time(typename base::absolute initialClock) + : base(initialClock) + { + } + + virtual item_type top() { + return queue.top(); + } + virtual void pop() { + queue.pop(); + } + virtual bool empty() { + return queue.empty(); + } + + virtual void schedule_absolute(typename base::absolute when, action a) + { + // use a separate subscription here so that a's subscription is not affected + auto run = make_action([a](action that, scheduler sc) { + if (that.is_subscribed()) { + that.unsubscribe(); // unsubscribe() run, not a; + (*a)(sc); + } + return make_action(); + }); + queue.push(item_type(when, run)); + } + +}; + + +} + +} + +#endif \ No newline at end of file -- GitLab From 0323430b2cc9bc41f1ee0a131b87232775359d9e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 14 Feb 2014 14:31:39 -0800 Subject: [PATCH 193/782] fixes for clang --- Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp index 5c20341..44dfc74 100644 --- a/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -234,11 +234,11 @@ protected: { // use a separate subscription here so that a's subscription is not affected auto run = make_action([a](action that, scheduler sc) { - if (that.is_subscribed()) { - that.unsubscribe(); // unsubscribe() run, not a; + if (that->is_subscribed()) { + that->unsubscribe(); // unsubscribe() run, not a; (*a)(sc); } - return make_action(); + return make_action_empty(); }); queue.push(item_type(when, run)); } @@ -250,4 +250,4 @@ protected: } -#endif \ No newline at end of file +#endif -- GitLab From 3981717e3538164bc9b1e1bd456b6bb90adfffb3 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 14 Feb 2014 14:18:37 -0800 Subject: [PATCH 194/782] added testscheduler and filter tests using it some tests are failing due to subscription lifetime issues. --- Rx/CPP/src/rxcpp/rx-notification.hpp | 25 +- Rx/CPP/src/rxcpp/rx-sources.hpp | 2 +- Rx/CPP/src/rxcpp/rx-test.hpp | 115 ++++++ Rx/CPP/src/rxcpp/rx-util.hpp | 12 +- Rx/CPP/src/rxcpp/rx.hpp | 105 ++++- Rx/CPP/src/rxcpp/schedulers/rx-test.hpp | 338 +++++++++++++++ .../src/rxcpp/schedulers/rx-virtualtime.hpp | 29 +- Rx/CPP/test/v2/operators/filter.cpp | 390 +++++++++++++++++- 8 files changed, 957 insertions(+), 59 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/rx-test.hpp create mode 100644 Rx/CPP/src/rxcpp/schedulers/rx-test.hpp diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/CPP/src/rxcpp/rx-notification.hpp index bf3207c..bdf86ef 100644 --- a/Rx/CPP/src/rxcpp/rx-notification.hpp +++ b/Rx/CPP/src/rxcpp/rx-notification.hpp @@ -30,12 +30,12 @@ public: template bool operator == (recorded lhs, recorded rhs) { - return lhs.Time() == rhs.Time() && lhs.Value() == rhs.Value(); + return lhs.time() == rhs.time() && lhs.value() == rhs.value(); } template std::ostream& operator<< (std::ostream& out, const recorded& r) { - out << "@" << r.Time() << "-" << r.Value(); + out << "@" << r.time() << "-" << r.value(); return out; } @@ -103,16 +103,13 @@ private: } virtual bool equals(const typename base::type& other) const { bool result = false; - other->accept(make_observer_dynamic([this, &result](T value) { + other->accept(make_observer_dynamic([this, &result](T value) { result = this->value == value; })); return result; } virtual void accept(const typename base::observer_type& o) const { - if (!o) { - abort(); - } - o->on_next(value); + o.on_next(value); } const T value; }; @@ -134,16 +131,13 @@ private: virtual bool equals(const typename base::type& other) const { bool result = false; // not trying to compare exceptions - other->accept(make_observer_dynamic(nullptr, [&result](std::exception_ptr){ + other->accept(make_observer_dynamic(nullptr, [&result](std::exception_ptr){ result = true; })); return result; } virtual void accept(const typename base::observer_type& o) const { - if (!o) { - abort(); - } - o->on_error(ep); + o.on_error(ep); } const std::exception_ptr ep; }; @@ -156,16 +150,13 @@ private: } virtual bool equals(const typename base::type& other) const { bool result = false; - other->Accept(make_observer_dynamic(nullptr, nullptr, [&result](){ + other->accept(make_observer_dynamic(nullptr, nullptr, [&result](){ result = true; })); return result; } virtual void accept(const typename base::observer_type& o) const { - if (!o) { - abort(); - } - o->on_completed(); + o.on_completed(); } }; diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp index bec8c55..7e585a1 100644 --- a/Rx/CPP/src/rxcpp/rx-sources.hpp +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -27,7 +27,7 @@ class is_source template static void check(...); public: - static const bool value = std::is_convertible(0)), tag_source>::value; + static const bool value = std::is_convertible::type>(0)), tag_source>::value; }; } diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/CPP/src/rxcpp/rx-test.hpp new file mode 100644 index 0000000..2a90279 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-test.hpp @@ -0,0 +1,115 @@ +#pragma once + +#if !defined(RXCPP_RX_TEST_HPP) +#define RXCPP_RX_TEST_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace test { + +namespace detail { + +template +struct test_subject_base + : public std::enable_shared_from_this> +{ + typedef rxn::recorded::type> recorded_type; + typedef std::shared_ptr> type; + + virtual void on_subscribe(observer>) const =0; + virtual std::vector messages() const =0; + virtual std::vector subscriptions() const =0; +}; + +template +struct test_source + : public rxs::source_base +{ + explicit test_source(typename test_subject_base::type ts) + : ts(std::move(ts)) + { + } + typename test_subject_base::type ts; + void on_subscribe(observer> o) const { + ts->on_subscribe(std::move(o)); + } + template + typename std::enable_if::type, observer>>::value, void>::type + on_subscribe(Observer o) const { + auto so = std::make_shared(o); + ts->on_subscribe(make_observer_dynamic( + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + })); + } +}; + +} + +template +class testable_observer + : public observer> +{ + typedef observer> observer_base; + typedef typename detail::test_subject_base::type test_subject; + test_subject ts; + +public: + typedef typename detail::test_subject_base::recorded_type recorded_type; + + testable_observer(test_subject ts, observer_base ob) + : observer_base(std::move(ob)) + , ts(std::move(ts)) + { + } + + std::vector messages() const { + return ts->messages(); + } +}; + +template +class testable_observable + : public observable> +{ + typedef observable> observable_base; + typedef typename detail::test_subject_base::type test_subject; + test_subject ts; + +public: + typedef typename detail::test_subject_base::recorded_type recorded_type; + + explicit testable_observable(test_subject ts) + : observable_base(detail::test_source(ts)) + , ts(ts) + { + } + + std::vector subscriptions() const { + return ts->subscriptions(); + } + + std::vector messages() const { + return ts->messages(); + } +}; + +} +namespace rxt=test; + +} + +#include "schedulers/rx-test.hpp" + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/rx-util.hpp b/Rx/CPP/src/rxcpp/rx-util.hpp index 380d53b..64a91ae 100644 --- a/Rx/CPP/src/rxcpp/rx-util.hpp +++ b/Rx/CPP/src/rxcpp/rx-util.hpp @@ -30,6 +30,13 @@ namespace rxcpp { +namespace util { + +template +std::vector to_vector(const T (&arr) [size]) { + return std::vector(std::begin(arr), std::end(arr)); +} + namespace detail { template @@ -68,6 +75,9 @@ private: } +} +namespace rxu=util; + } #define RXCPP_UNWIND(Name, Function) \ @@ -78,6 +88,6 @@ private: #define RXCPP_UNWIND_EXPLICIT(FunctionName, UnwinderName, Function) \ auto FunctionName = (Function); \ - rxcpp::detail::unwinder UnwinderName(std::addressof(FunctionName)) + rxcpp::util::detail::unwinder UnwinderName(std::addressof(FunctionName)) #endif diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index c46eeca..e5e7df9 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -9,14 +9,67 @@ namespace rxcpp { +template +struct dynamic_observable + : public rxs::source_base +{ + struct state_type + : public std::enable_shared_from_this + { + typedef std::function>)> onsubscribe_type; + + onsubscribe_type on_subscribe; + }; + std::shared_ptr state; + + dynamic_observable() + { + } + + template + explicit dynamic_observable(Source source) + : state(std::make_shared()) + { + state->on_subscribe = [source](observer> o) mutable { + source.on_subscribe(std::move(o)); + }; + } + + void on_subscribe(observer> o) const { + state->on_subscribe(std::move(o)); + } + + template + typename std::enable_if::type, observer>>::value, void>::type + on_subscribe(Observer o) const { + auto so = std::make_shared(o); + state->on_subscribe(make_observer_dynamic( + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + })); + } +}; + template class observable { - SourceOperator source_operator; + mutable SourceOperator source_operator; private: + template + friend class observable; + template - auto detail_subscribe(observer o, tag_observer&&) + auto detail_subscribe(observer o, tag_observer&&) const -> decltype(make_subscription(o)) { if (!o.is_subscribed()) { @@ -51,31 +104,31 @@ private: struct tag_function {}; template - auto detail_subscribe(OnNext n, tag_function&&) + auto detail_subscribe(OnNext n, tag_function&&) const -> decltype(make_subscription( make_observer(std::move(n)))) { return subscribe( make_observer(std::move(n))); } template - auto detail_subscribe(OnNext n, OnError e, tag_function&&) + auto detail_subscribe(OnNext n, OnError e, tag_function&&) const -> decltype(make_subscription( make_observer(std::move(n), std::move(e)))) { return subscribe( make_observer(std::move(n), std::move(e))); } template - auto detail_subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) + auto detail_subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) const -> decltype(make_subscription( make_observer(std::move(n), std::move(e), std::move(c)))) { return subscribe( make_observer(std::move(n), std::move(e), std::move(c))); } template - auto detail_subscribe(composite_subscription cs, OnNext n, tag_subscription&&) + auto detail_subscribe(composite_subscription cs, OnNext n, tag_subscription&&) const -> decltype(make_subscription( make_observer(std::move(cs), std::move(n)))) { return subscribe( make_observer(std::move(cs), std::move(n))); } template - auto detail_subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) + auto detail_subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) const -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e)))) { return subscribe( make_observer(std::move(cs), std::move(n), std::move(e))); } @@ -85,39 +138,65 @@ public: static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); + observable() + { + } + explicit observable(const SourceOperator& o) : source_operator(o) - {} + { + } explicit observable(SourceOperator&& o) : source_operator(std::move(o)) + { + } + + // implicit conversion between observables of the same value_type + template + observable(const observable& o) + : source_operator(o.source_operator) {} +#if 0 + template + void on_subscribe(observer o) const { + source_operator.on_subscribe(o); + } +#endif + + // + // performs type-forgetting conversion + // + observable> as_dynamic() { + return *this; + } + template - auto subscribe(Arg a) + auto subscribe(Arg a) const -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type())) { return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type()); } template - auto subscribe(Arg1 a1, Arg2 a2) + auto subscribe(Arg1 a1, Arg2 a2) const -> decltype(detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type())) { return detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type()); } template - auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) + auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) const -> decltype(detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type())) { return detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type()); } template - auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) + auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) const -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c)))) { return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } template - auto filter(Predicate p) + auto filter(Predicate p) const -> observable> { return observable>( rxo::detail::filter(*this, std::move(p))); diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp new file mode 100644 index 0000000..d814f1e --- /dev/null +++ b/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp @@ -0,0 +1,338 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_TEST_HPP) +#define RXCPP_RX_SCHEDULER_TEST_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +class test : public virtual_time +{ +public: + typedef virtual_time base; + typedef base::clock_type clock_type; + typedef std::shared_ptr shared; + + static const long created_time = 100; + static const long subscribed_time = 200; + static const long unsubscribed_time = 1000; + + template + struct messages + { + typedef typename rxn::notification notification_type; + typedef rxn::recorded recorded_type; + + static + recorded_type on_next(long ticks, T value) + { + return recorded_type(ticks, notification_type::make_on_next(value)); + } + + static + recorded_type on_completed(long ticks) + { + return recorded_type(ticks, notification_type::make_on_completed()); + } + + template + static + recorded_type on_error(long ticks, Exception e) + { + return recorded_type(ticks, notification_type::make_on_error(e)); + } + + static + rxn::subscription subscribe(long subscribe, long unsubscribe) + { + return rxn::subscription(subscribe, unsubscribe); + } + + private: + ~messages(); + }; + + using base::schedule_absolute; + using base::schedule_relative; + + virtual void schedule_absolute(long when, action a) + { + if (when <= base::clock_now) + when = base::clock_now + 1; + + return base::schedule_absolute(when, std::move(a)); + } + + virtual long add(long absolute, long relative) + { + return absolute + relative; + } + + virtual clock_type::time_point to_time_point(long absolute) + { + return clock_type::time_point(clock_type::duration(absolute)); + } + + virtual long to_relative(clock_type::duration d) + { + return static_cast(d.count()); + } + + using base::start; + + template + auto start(F createSource, long created, long subscribed, long unsubscribed) + -> rxt::testable_observer + { + struct state_type + { + typedef decltype(createSource()) source_type; + typedef typename source_type::value_type value_type; + + explicit state_type(rxt::testable_observer o) + : observer(o) + { + } + std::unique_ptr source; + rxt::testable_observer observer; + }; + auto state = std::make_shared(make_observer()); + + schedule_absolute(created, make_action([createSource, state](action, scheduler) { + state->source.reset(new typename state_type::source_type(createSource())); + return make_action_empty(); + })); + schedule_absolute(subscribed, make_action([state](action, scheduler) { + state->source->subscribe(state->observer); + return make_action_empty(); + })); + schedule_absolute(unsubscribed, make_action([state](action, scheduler) { + state->observer.unsubscribe(); + return make_action_empty(); + })); + + start(); + + return state->observer; + } + + template + auto start(F createSource, long unsubscribed) + -> rxt::testable_observer + { + return start(std::move(createSource), created_time, subscribed_time, unsubscribed); + } + + template + auto start(F createSource) + -> rxt::testable_observer + { + return start(std::move(createSource), created_time, subscribed_time, unsubscribed_time); + } + + template + rxt::testable_observable make_hot_observable(std::vector>>> messages); + + template + auto make_hot_observable(const T (&arr) [size]) + -> decltype(make_hot_observable(std::vector())) { + return make_hot_observable(rxu::to_vector(arr)); + } + + template + rxt::testable_observable make_cold_observable(std::vector>>> messages); + + template + auto make_cold_observable(const T (&arr) [size]) + -> decltype(make_cold_observable(std::vector())) { + return make_cold_observable(rxu::to_vector(arr)); + } + + template + rxt::testable_observer make_observer(); +}; + +template +class mock_observer + : public rxt::detail::test_subject_base +{ + typedef typename rxn::notification notification_type; + typedef rxn::recorded recorded_type; + +public: + mock_observer(typename test::shared sc) + : sc(sc) + { + } + + typename test::shared sc; + std::vector m; + + virtual void on_subscribe(observer>) const { + abort(); + } + virtual std::vector subscriptions() const { + abort(); return std::vector(); + } + + virtual std::vector messages() const { + return m; + } +}; + +template +rxt::testable_observer test::make_observer() +{ + typedef typename rxn::notification notification_type; + typedef rxn::recorded recorded_type; + + auto ts = std::make_shared>( + std::static_pointer_cast(shared_from_this())); + + return rxt::testable_observer(ts, make_observer_dynamic( + // on_next + [ts](T value) + { + ts->m.push_back( + recorded_type(ts->sc->clock(), notification_type::make_on_next(value))); + }, + // on_error + [ts](std::exception_ptr e) + { + ts->m.push_back( + recorded_type(ts->sc->clock(), notification_type::make_on_error(e))); + }, + // on_completed + [ts]() + { + ts->m.push_back( + recorded_type(ts->sc->clock(), notification_type::make_on_completed())); + })); +} + +template +class cold_observable + : public rxt::detail::test_subject_base +{ + typedef cold_observable this_type; + typename test::shared sc; + typedef rxn::recorded::type> recorded_type; + mutable std::vector mv; + mutable std::vector sv; + +public: + + cold_observable(typename test::shared sc, std::vector mv) + : sc(sc) + , mv(std::move(mv)) + { + } + + template + cold_observable(typename test::shared sc, Iterator begin, Iterator end) + : scheduler(sc) + , mv(begin, end) + { + } + + virtual void on_subscribe(observer> o) const { + sv.push_back(rxn::subscription(sc->clock())); + auto index = sv.size() - 1; + + for (auto& message : mv) { + auto n = message.value(); + scheduler->schedule_relative(message.time(), make_action([n, o](action, scheduler) { + n->accept(o); + return make_action_empty(); + })); + } + + auto sharedThis = std::static_pointer_cast(this->shared_from_this()); + o.add(dynamic_subscription([sharedThis, index]() { + sharedThis->sv[index] = rxn::subscription(sharedThis->sv[index].subscribe(), sharedThis->sc->clock()); + })); + } + + virtual std::vector subscriptions() const { + return sv; + } + + virtual std::vector messages() const { + return mv; + } +}; + +template +rxt::testable_observable test::make_cold_observable(std::vector>>> messages) +{ + return rxt::testable_observable(std::make_shared>( + std::static_pointer_cast(shared_from_this()), std::move(messages))); +} + +template +class hot_observable + : public rxt::detail::test_subject_base +{ + typedef hot_observable this_type; + typename test::shared sc; + typedef rxn::recorded::type> recorded_type; + typedef observer> observer_type; + mutable std::vector mv; + mutable std::vector sv; + mutable std::vector observers; + +public: + + hot_observable(typename test::shared sc, std::vector mv) + : sc(sc) + , mv(mv) + { + for (auto& message : mv) { + auto n = message.value(); + sc->schedule_absolute(message.time(), make_action([this, n](action, scheduler) { + auto local = this->observers; + for (auto& o : local) { + n->accept(o); + } + return make_action_empty(); + })); + } + } + + virtual void on_subscribe(observer_type o) const { + observers.push_back(o); + sv.push_back(rxn::subscription(sc->clock())); + auto index = sv.size() - 1; + + auto sharedThis = std::static_pointer_cast(this->shared_from_this()); + o.add(dynamic_subscription([sharedThis, index]() { + sharedThis->sv[index] = rxn::subscription(sharedThis->sv[index].subscribe(), sharedThis->sc->clock()); + })); + } + + virtual std::vector subscriptions() const { + return sv; + } + + virtual std::vector messages() const { + return mv; + } +}; + +template +rxt::testable_observable test::make_hot_observable(std::vector>>> messages) +{ + return rxt::testable_observable(std::make_shared>( + std::static_pointer_cast(shared_from_this()), std::move(messages))); +} + +} + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp index 44dfc74..42f87f8 100644 --- a/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -17,7 +17,7 @@ template struct virtual_time_base : public scheduler_base { private: - typedef virtual_time_base this_type; + typedef virtual_time_base this_type; virtual_time_base(const virtual_time_base&); bool isenabled; @@ -44,12 +44,12 @@ protected: absolute clock_now; - typedef time_action item_type; + typedef time_action item_type; virtual absolute add(absolute, relative) =0; - virtual typename this_type::clock_type::time_point to_time_point(absolute) =0; - virtual relative to_relative(typename this_type::clock_type::duration) =0; + virtual typename scheduler_base::clock_type::time_point to_time_point(absolute) =0; + virtual relative to_relative(typename scheduler_base::clock_type::duration) =0; virtual item_type top() =0; virtual void pop() =0; @@ -58,11 +58,23 @@ protected: public: virtual void schedule_absolute(absolute, action) =0; - virtual void schedule_relative(relative dueTime, action a) { - auto at = add(clock_now, dueTime); + template + typename std::enable_if::type, action>::value, void>::type + schedule_absolute(absolute when, F f) { + schedule_absolute(when, make_action(f)); + } + + virtual void schedule_relative(relative when, action a) { + auto at = add(clock_now, when); return schedule_absolute(at, std::move(a)); } + template + typename std::enable_if::type, action>::value, void>::type + schedule_relative(relative when, F f) { + schedule_relative(when, make_action(f)); + } + bool is_enabled() {return isenabled;} absolute clock() {return clock_now;} @@ -78,7 +90,7 @@ public: clock_now = next.when; } auto a = (*next.a)(shared_from_this()); - if (a.subscribed()) { + if (a->is_subscribed()) { schedule(a); } } @@ -230,6 +242,9 @@ protected: return queue.empty(); } + using base::schedule_absolute; + using base::schedule_relative; + virtual void schedule_absolute(typename base::absolute when, action a) { // use a separate subscription here so that a's subscription is not affected diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 18dbdb5..f415c10 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,7 +1,13 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; +namespace rxu=rxcpp::util; namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; #include "catch.hpp" @@ -18,31 +24,375 @@ bool IsPrime(int x) } } -SCENARIO("filter members", "[filter][operators][traits]"){ - GIVEN("given a range of ints from 1 to 100"){ - WHEN("filtered to primes"){ - THEN("a subscription only observes primes"){ - auto s = rx::observable<>::range(1, 100, 1) - .filter(IsPrime) - .subscribe([](int t) { - const auto prime = IsPrime(t) ? t : -1; - REQUIRE( t == prime ); - }); +SCENARIO("filter stops on completion", "[filter][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + long invoked = 0; + + m::recorded_type messages[] = { + m::on_next(110, 1), + m::on_next(180, 2), + m::on_next(230, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(380, 6), + m::on_next(390, 7), + m::on_next(450, 8), + m::on_next(470, 9), + m::on_next(560, 10), + m::on_next(580, 11), + m::on_completed(600), + m::on_next(610, 12), + m::on_error(620, std::exception()), + m::on_completed(630) + }; + auto xs = sc->make_hot_observable(messages); + + WHEN("filtered to ints that are primes"){ + auto res = sc->start( + [&xs, &invoked]() { + return xs + .filter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains primes"){ + m::recorded_type items[] = { + m::on_next(230, 3), + m::on_next(340, 5), + m::on_next(390, 7), + m::on_next(580, 11), + m::on_completed(600) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rxn::subscription items[] = { + m::subscribe(200, 600) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("filter was called until completed"){ + REQUIRE(9 == invoked); + } + } + } +} + + +SCENARIO("where stops on disposal", "[where][filter][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + long invoked = 0; + + m::recorded_type messages[] = { + m::on_next(110, 1), + m::on_next(180, 2), + m::on_next(230, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(380, 6), + m::on_next(390, 7), + m::on_next(450, 8), + m::on_next(470, 9), + m::on_next(560, 10), + m::on_next(580, 11), + m::on_completed(600) + }; + auto xs = sc->make_hot_observable(rxu::to_vector(messages)); + + WHEN("filtered to ints that are primes"){ + + auto res = sc->start( + [&xs, &invoked]() { + return xs + .filter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 400 + ); + + THEN("the output only contains primes that arrived before disposal"){ + m::recorded_type items[] = { + m::on_next(230, 3), + m::on_next(340, 5), + m::on_next(390, 7) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rxn::subscription items[] = { + m::subscribe(200, 400) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(5 == invoked); + } + } + } +} + +SCENARIO("where stops on error", "[where][filter][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + long invoked = 0; + + std::exception ex; + + auto xs = sc->make_hot_observable( + [ex]() { + m::recorded_type messages[] = { + m::on_next(110, 1), + m::on_next(180, 2), + m::on_next(230, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(380, 6), + m::on_next(390, 7), + m::on_next(450, 8), + m::on_next(470, 9), + m::on_next(560, 10), + m::on_next(580, 11), + m::on_error(600, ex), + m::on_next(610, 12), + m::on_error(620, std::exception()), + m::on_completed(630) + }; + return rxu::to_vector(messages); + }() + ); + + WHEN("filtered to ints that are primes"){ + + auto res = sc->start( + [xs, &invoked]() { + return xs + .filter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains primes"){ + m::recorded_type items[] = { + m::on_next(230, 3), + m::on_next(340, 5), + m::on_next(390, 7), + m::on_next(580, 11), + m::on_error(600, ex), + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rxn::subscription items[] = { + m::subscribe(200, 600) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until error"){ + REQUIRE(9 == invoked); + } + } + } +} + +SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + long invoked = 0; + + std::exception ex; + + auto xs = sc->make_hot_observable( + []() { + m::recorded_type messages[] = { + m::on_next(110, 1), + m::on_next(180, 2), + m::on_next(230, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(380, 6), + m::on_next(390, 7), + m::on_next(450, 8), + m::on_next(470, 9), + m::on_next(560, 10), + m::on_next(580, 11), + m::on_completed(600), + m::on_next(610, 12), + m::on_error(620, std::exception()), + m::on_completed(630) + }; + return rxu::to_vector(messages); + }() + ); + + WHEN("filtered to ints that are primes"){ + + auto res = sc->start( + [ex, xs, &invoked]() { + return xs + .filter([ex, &invoked](int x) { + invoked++; + if (x > 5) { + throw ex; + } + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains primes"){ + m::recorded_type items[] = { + m::on_next(230, 3), + m::on_next(340, 5), + m::on_error(380, ex) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rxn::subscription items[] = { + m::subscribe(200, 380) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until error"){ + REQUIRE(4 == invoked); } } } } -SCENARIO("filter operators", "[filter][operators][traits]"){ - GIVEN("given a range of ints from 1 to 100"){ - WHEN("filtered to primes"){ - THEN("a subscription only observes primes"){ - auto s = rxs::range(1, 100, 1) - >> rxo::filter(IsPrime) - >> rxo::subscribe([](int t) { - const auto prime = IsPrime(t) ? t : -1; - REQUIRE( t == prime ); - }); +SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + long invoked = 0; + + auto xs = sc->make_hot_observable( + []() { + m::recorded_type messages[] = { + m::on_next(110, 1), + m::on_next(180, 2), + m::on_next(230, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(380, 6), + m::on_next(390, 7), + m::on_next(450, 8), + m::on_next(470, 9), + m::on_next(560, 10), + m::on_next(580, 11), + m::on_completed(600), + m::on_next(610, 12), + m::on_error(620, std::exception()), + m::on_completed(630) + }; + return rxu::to_vector(messages); + }() + ); + + auto res = sc->make_observer(); + + rx::observable> ys; + + WHEN("filtered to ints that are primes"){ + + sc->schedule_absolute(rxsc::test::created_time, + [&invoked, &res, &ys, &xs](rxsc::action, rxsc::scheduler) { + ys = xs + .filter([&invoked, &res](int x) { + invoked++; + if (x == 8) + res.unsubscribe(); + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + return rxsc::make_action_empty(); + }); + + sc->schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](rxsc::action, rxsc::scheduler) { + ys.subscribe(res); + return rxsc::make_action_empty(); + }); + + sc->schedule_absolute(rxsc::test::unsubscribed_time, [&res](rxsc::action, rxsc::scheduler) { + res.unsubscribe(); + return rxsc::make_action_empty(); + }); + + sc->start(); + + THEN("the output only contains primes"){ + m::recorded_type items[] = { + m::on_next(230, 3), + m::on_next(340, 5), + m::on_next(390, 7) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rxn::subscription items[] = { + m::subscribe(200, 450) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(6 == invoked); } } } -- GitLab From ead6a749622af563bd9df7224b2bb81748e6b8d0 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 14 Feb 2014 14:27:11 -0800 Subject: [PATCH 195/782] there, now the filter tests pass --- Rx/CPP/src/rxcpp/rx-test.hpp | 1 + Rx/CPP/src/rxcpp/rx.hpp | 1 + 2 files changed, 2 insertions(+) diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/CPP/src/rxcpp/rx-test.hpp index 2a90279..594030a 100644 --- a/Rx/CPP/src/rxcpp/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/rx-test.hpp @@ -40,6 +40,7 @@ struct test_source on_subscribe(Observer o) const { auto so = std::make_shared(o); ts->on_subscribe(make_observer_dynamic( + so->get_subscription(), // on_next [so](T t){ so->on_next(t); diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index e5e7df9..da2f660 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -44,6 +44,7 @@ struct dynamic_observable on_subscribe(Observer o) const { auto so = std::make_shared(o); state->on_subscribe(make_observer_dynamic( + so->get_subscription(), // on_next [so](T t){ so->on_next(t); -- GitLab From 43b517916778fba64a96d6c830b93a963ddece91 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 14 Feb 2014 15:10:08 -0800 Subject: [PATCH 196/782] clang fixes --- Rx/CPP/src/rxcpp/rx-notification.hpp | 79 +++++++++++++------------ Rx/CPP/src/rxcpp/schedulers/rx-test.hpp | 24 ++++---- 2 files changed, 53 insertions(+), 50 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/CPP/src/rxcpp/rx-notification.hpp index bdf86ef..4bdd5bd 100644 --- a/Rx/CPP/src/rxcpp/rx-notification.hpp +++ b/Rx/CPP/src/rxcpp/rx-notification.hpp @@ -11,34 +11,6 @@ namespace rxcpp { namespace notifications { -template -class recorded -{ - long t; - T v; -public: - recorded(long t, T v) - : t(t), v(v) { - } - long time() const { - return t; - } - const T& value() const { - return v; - } -}; - -template -bool operator == (recorded lhs, recorded rhs) { - return lhs.time() == rhs.time() && lhs.value() == rhs.value(); -} - -template -std::ostream& operator<< (std::ostream& out, const recorded& r) { - out << "@" << r.time() << "-" << r.value(); - return out; -} - class subscription { long s; @@ -98,8 +70,8 @@ private: struct on_next_notification : public base { on_next_notification(T value) : value(std::move(value)) { } - virtual void out(std::ostream& out) const { - out << "on_next( " << value << ")"; + virtual void out(std::ostream& os) const { + os << "on_next( " << value << ")"; } virtual bool equals(const typename base::type& other) const { bool result = false; @@ -117,16 +89,16 @@ private: struct on_error_notification : public base { on_error_notification(std::exception_ptr ep) : ep(ep) { } - virtual void out(std::ostream& out) const { - out << "on_error("; + virtual void out(std::ostream& os) const { + os << "on_error("; try { std::rethrow_exception(ep); } catch (const std::exception& e) { - out << e.what(); + os << e.what(); } catch (...) { - out << ""; + os << ""; } - out << ")"; + os << ")"; } virtual bool equals(const typename base::type& other) const { bool result = false; @@ -145,8 +117,8 @@ private: struct on_completed_notification : public base { on_completed_notification() { } - virtual void out(std::ostream& out) const { - out << "on_completed()"; + virtual void out(std::ostream& os) const { + os << "on_completed()"; } virtual bool equals(const typename base::type& other) const { bool result = false; @@ -209,8 +181,37 @@ bool operator == (const std::shared_ptr>& lhs, cons } template -std::ostream& operator<< (std::ostream& out, const std::shared_ptr>& n) { - n->out(out); +std::ostream& operator<< (std::ostream& os, const std::shared_ptr>& n) { + n->out(os); + return os; +} + + +template +class recorded +{ + long t; + T v; +public: + recorded(long t, T v) + : t(t), v(v) { + } + long time() const { + return t; + } + const T& value() const { + return v; + } +}; + +template +bool operator == (recorded lhs, recorded rhs) { + return lhs.time() == rhs.time() && lhs.value() == rhs.value(); +} + +template +std::ostream& operator<< (std::ostream& out, const recorded& r) { + out << "@" << r.time() << "-" << r.value(); return out; } diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp index d814f1e..39cd0af 100644 --- a/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp @@ -90,35 +90,37 @@ public: -> rxt::testable_observer { struct state_type + : public std::enable_shared_from_this { typedef decltype(createSource()) source_type; - typedef typename source_type::value_type value_type; - explicit state_type(rxt::testable_observer o) - : observer(o) + std::unique_ptr source; + rxt::testable_observer o; + + explicit state_type(rxt::testable_observer o) + : source() + , o(o) { } - std::unique_ptr source; - rxt::testable_observer observer; }; - auto state = std::make_shared(make_observer()); + std::shared_ptr state(new state_type(this->make_observer())); schedule_absolute(created, make_action([createSource, state](action, scheduler) { state->source.reset(new typename state_type::source_type(createSource())); return make_action_empty(); })); schedule_absolute(subscribed, make_action([state](action, scheduler) { - state->source->subscribe(state->observer); + state->source->subscribe(state->o); return make_action_empty(); })); schedule_absolute(unsubscribed, make_action([state](action, scheduler) { - state->observer.unsubscribe(); + state->o.unsubscribe(); return make_action_empty(); })); start(); - return state->observer; + return state->o; } template @@ -246,7 +248,7 @@ public: for (auto& message : mv) { auto n = message.value(); - scheduler->schedule_relative(message.time(), make_action([n, o](action, scheduler) { + sc->schedule_relative(message.time(), make_action([n, o](action, scheduler) { n->accept(o); return make_action_empty(); })); @@ -335,4 +337,4 @@ rxt::testable_observable test::make_hot_observable(std::vector Date: Fri, 14 Feb 2014 15:52:37 -0800 Subject: [PATCH 197/782] testing '.operator()' vs. '>> rxo::operator()' --- Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp | 19 +++++++ Rx/CPP/src/rxcpp/rx-includes.hpp | 2 +- Rx/CPP/src/rxcpp/rx-operators.hpp | 5 -- Rx/CPP/src/rxcpp/rx-sources.hpp | 51 +++++++++++++++++ Rx/CPP/src/rxcpp/rx.hpp | 58 ++++---------------- Rx/CPP/test/v2/operators/filter.cpp | 61 +++++++++++++++++++-- 6 files changed, 139 insertions(+), 57 deletions(-) diff --git a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp index e8495bf..e8adadb 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp @@ -127,6 +127,25 @@ auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) return detail::subscribe_factory(std::move(cs), std::move(n), std::move(e), std::move(c)); } +namespace detail { + +class dynamic_factory +{ +public: + template + auto operator()(Observable source) + -> observable> { + return observable>(source); + } +}; + +} + +inline auto as_dynamic() + -> detail::dynamic_factory { + return detail::dynamic_factory(); +} + } } diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index 07f4b7f..6beae24 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -94,8 +94,8 @@ #include "rx-observer.hpp" #include "rx-notification.hpp" #include "rx-scheduler.hpp" -#include "rx-operators.hpp" #include "rx-sources.hpp" +#include "rx-operators.hpp" #pragma pop_macro("min") #pragma pop_macro("max") diff --git a/Rx/CPP/src/rxcpp/rx-operators.hpp b/Rx/CPP/src/rxcpp/rx-operators.hpp index 551a0ab..519c136 100644 --- a/Rx/CPP/src/rxcpp/rx-operators.hpp +++ b/Rx/CPP/src/rxcpp/rx-operators.hpp @@ -9,11 +9,6 @@ namespace rxcpp { - -template -class observable; - - namespace operators { diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp index 7e585a1..b8a6999 100644 --- a/Rx/CPP/src/rxcpp/rx-sources.hpp +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -33,6 +33,57 @@ public: } namespace rxs=sources; +template +struct dynamic_observable + : public rxs::source_base +{ + struct state_type + : public std::enable_shared_from_this + { + typedef std::function>)> onsubscribe_type; + + onsubscribe_type on_subscribe; + }; + std::shared_ptr state; + + dynamic_observable() + { + } + + template + explicit dynamic_observable(Source source) + : state(std::make_shared()) + { + state->on_subscribe = [source](observer> o) mutable { + source.on_subscribe(std::move(o)); + }; + } + + void on_subscribe(observer> o) const { + state->on_subscribe(std::move(o)); + } + + template + typename std::enable_if::type, observer>>::value, void>::type + on_subscribe(Observer o) const { + auto so = std::make_shared(o); + state->on_subscribe(make_observer_dynamic( + so->get_subscription(), + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + })); + } +}; + } #include "sources/rx-range.hpp" diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index da2f660..38adcef 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -5,60 +5,22 @@ #if !defined(RXCPP_RX_HPP) #define RXCPP_RX_HPP -#include "rx-includes.hpp" - namespace rxcpp { template -struct dynamic_observable - : public rxs::source_base -{ - struct state_type - : public std::enable_shared_from_this - { - typedef std::function>)> onsubscribe_type; +struct dynamic_observable; - onsubscribe_type on_subscribe; - }; - std::shared_ptr state; +template< + class T = void, + class SourceObservable = std::conditional::value, + void, dynamic_observable>::type> +class observable; - dynamic_observable() - { - } +} - template - explicit dynamic_observable(Source source) - : state(std::make_shared()) - { - state->on_subscribe = [source](observer> o) mutable { - source.on_subscribe(std::move(o)); - }; - } +#include "rx-includes.hpp" - void on_subscribe(observer> o) const { - state->on_subscribe(std::move(o)); - } - - template - typename std::enable_if::type, observer>>::value, void>::type - on_subscribe(Observer o) const { - auto so = std::make_shared(o); - state->on_subscribe(make_observer_dynamic( - so->get_subscription(), - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - })); - } -}; +namespace rxcpp { template class observable @@ -196,12 +158,14 @@ public: return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } +#if RXCPP_USE_OBSERVABLE_MEMBERS template auto filter(Predicate p) const -> observable> { return observable>( rxo::detail::filter(*this, std::move(p))); } +#endif }; // observable<> has static methods to construct observable sources and adaptors. diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index f415c10..cd2fdf6 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,3 +1,6 @@ + +#define RXCPP_USE_OBSERVABLE_MEMBERS 1 + #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; @@ -53,6 +56,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ WHEN("filtered to ints that are primes"){ auto res = sc->start( [&xs, &invoked]() { +#if RXCPP_USE_OBSERVABLE_MEMBERS return xs .filter([&invoked](int x) { invoked++; @@ -60,9 +64,17 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ }) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); +#else + return xs + >> rxo::filter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + >> rxo::as_dynamic(); +#endif } ); - THEN("the output only contains primes"){ m::recorded_type items[] = { m::on_next(230, 3), @@ -120,6 +132,7 @@ SCENARIO("where stops on disposal", "[where][filter][operators]"){ auto res = sc->start( [&xs, &invoked]() { +#if RXCPP_USE_OBSERVABLE_MEMBERS return xs .filter([&invoked](int x) { invoked++; @@ -127,6 +140,15 @@ SCENARIO("where stops on disposal", "[where][filter][operators]"){ }) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); +#else + return xs + >> rxo::filter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + >> rxo::as_dynamic(); +#endif }, 400 ); @@ -194,6 +216,7 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ auto res = sc->start( [xs, &invoked]() { +#if RXCPP_USE_OBSERVABLE_MEMBERS return xs .filter([&invoked](int x) { invoked++; @@ -201,6 +224,15 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ }) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); +#else + return xs + >> rxo::filter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + >> rxo::as_dynamic(); +#endif } ); @@ -269,6 +301,7 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ auto res = sc->start( [ex, xs, &invoked]() { +#if RXCPP_USE_OBSERVABLE_MEMBERS return xs .filter([ex, &invoked](int x) { invoked++; @@ -279,6 +312,18 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ }) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); +#else + return xs + >> rxo::filter([ex, &invoked](int x) { + invoked++; + if (x > 5) { + throw ex; + } + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + >> rxo::as_dynamic(); +#endif } ); @@ -347,15 +392,23 @@ SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ sc->schedule_absolute(rxsc::test::created_time, [&invoked, &res, &ys, &xs](rxsc::action, rxsc::scheduler) { +#if RXCPP_USE_OBSERVABLE_MEMBERS ys = xs .filter([&invoked, &res](int x) { invoked++; if (x == 8) res.unsubscribe(); return IsPrime(x); - }) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); + }); +#else + ys = xs + >> rxo::filter([&invoked, &res](int x) { + invoked++; + if (x == 8) + res.unsubscribe(); + return IsPrime(x); + }); +#endif return rxsc::make_action_empty(); }); -- GitLab From b78e30f9aa61f355be41f4faa3c650942c798c50 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 14 Feb 2014 15:58:01 -0800 Subject: [PATCH 198/782] clang fixes --- Rx/CPP/src/rxcpp/rx-includes.hpp | 1 + Rx/CPP/src/rxcpp/rx-predef.hpp | 24 ++++++++++++++++++++++++ Rx/CPP/src/rxcpp/rx.hpp | 13 ------------- 3 files changed, 25 insertions(+), 13 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/rx-predef.hpp diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index 6beae24..52c2283 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -90,6 +90,7 @@ #endif #include "rx-util.hpp" +#include "rx-predef.hpp" #include "rx-subscription.hpp" #include "rx-observer.hpp" #include "rx-notification.hpp" diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/CPP/src/rxcpp/rx-predef.hpp new file mode 100644 index 0000000..bb29b73 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-predef.hpp @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_PREDEF_HPP) +#define RXCPP_RX_PREDEF_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +template +struct dynamic_observable; + +template< + class T = void, + class SourceObservable = typename std::conditional::value, + void, dynamic_observable>::type> +class observable; + + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 38adcef..8e0e9c9 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -5,19 +5,6 @@ #if !defined(RXCPP_RX_HPP) #define RXCPP_RX_HPP -namespace rxcpp { - -template -struct dynamic_observable; - -template< - class T = void, - class SourceObservable = std::conditional::value, - void, dynamic_observable>::type> -class observable; - -} - #include "rx-includes.hpp" namespace rxcpp { -- GitLab From f820b2eac9a4469c51f017ef9f84ded2073e972d Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 14 Feb 2014 16:57:04 -0800 Subject: [PATCH 199/782] use default template args for observable/observer --- Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp | 4 ++-- Rx/CPP/src/rxcpp/rx-notification.hpp | 2 +- Rx/CPP/src/rxcpp/rx-observer.hpp | 11 +++++------ Rx/CPP/src/rxcpp/rx-predef.hpp | 8 +++++++- Rx/CPP/src/rxcpp/rx-sources.hpp | 8 ++++---- Rx/CPP/src/rxcpp/rx-test.hpp | 22 ++++++++++----------- Rx/CPP/src/rxcpp/rx.hpp | 2 +- Rx/CPP/src/rxcpp/schedulers/rx-test.hpp | 6 +++--- 8 files changed, 34 insertions(+), 29 deletions(-) diff --git a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp index e8adadb..0a53734 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp @@ -134,8 +134,8 @@ class dynamic_factory public: template auto operator()(Observable source) - -> observable> { - return observable>(source); + -> observable { + return observable(source); } }; diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/CPP/src/rxcpp/rx-notification.hpp index 4bdd5bd..503c392 100644 --- a/Rx/CPP/src/rxcpp/rx-notification.hpp +++ b/Rx/CPP/src/rxcpp/rx-notification.hpp @@ -46,7 +46,7 @@ template struct notification_base : public std::enable_shared_from_this> { - typedef observer> observer_type; + typedef observer observer_type; typedef std::shared_ptr> type; virtual ~notification_base() {} diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index 644d29b..976d6fc 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -235,9 +235,8 @@ template class observer : public observer_root { typedef observer this_type; - typedef typename std::conditional::value, I, dynamic_observer>::type + typedef typename std::conditional::value, I, dynamic_observer>::type inner_t; - inner_t; inner_t inner; public: ~observer() @@ -411,14 +410,14 @@ auto make_observer(composite_subscription cs, OnNext n, OnError e, OnCompleted c template auto make_observer_dynamic(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) - -> observer> { - return observer>(dynamic_observer(std::move(n), std::move(e), std::move(c))); + -> observer { + return observer(dynamic_observer(std::move(n), std::move(e), std::move(c))); } template auto make_observer_dynamic(composite_subscription cs, typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) - -> observer> { - return observer>(dynamic_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); + -> observer { + return observer(dynamic_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } } diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/CPP/src/rxcpp/rx-predef.hpp index bb29b73..8da4f9f 100644 --- a/Rx/CPP/src/rxcpp/rx-predef.hpp +++ b/Rx/CPP/src/rxcpp/rx-predef.hpp @@ -9,6 +9,12 @@ namespace rxcpp { +template +class dynamic_observer; + +template> +class observer; + template struct dynamic_observable; @@ -21,4 +27,4 @@ class observable; } -#endif \ No newline at end of file +#endif diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp index b8a6999..a732178 100644 --- a/Rx/CPP/src/rxcpp/rx-sources.hpp +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -40,7 +40,7 @@ struct dynamic_observable struct state_type : public std::enable_shared_from_this { - typedef std::function>)> onsubscribe_type; + typedef std::function)> onsubscribe_type; onsubscribe_type on_subscribe; }; @@ -54,17 +54,17 @@ struct dynamic_observable explicit dynamic_observable(Source source) : state(std::make_shared()) { - state->on_subscribe = [source](observer> o) mutable { + state->on_subscribe = [source](observer o) mutable { source.on_subscribe(std::move(o)); }; } - void on_subscribe(observer> o) const { + void on_subscribe(observer o) const { state->on_subscribe(std::move(o)); } template - typename std::enable_if::type, observer>>::value, void>::type + typename std::enable_if::type, observer>::value, void>::type on_subscribe(Observer o) const { auto so = std::make_shared(o); state->on_subscribe(make_observer_dynamic( diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/CPP/src/rxcpp/rx-test.hpp index 594030a..4280e1f 100644 --- a/Rx/CPP/src/rxcpp/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/rx-test.hpp @@ -18,13 +18,13 @@ struct test_subject_base typedef rxn::recorded::type> recorded_type; typedef std::shared_ptr> type; - virtual void on_subscribe(observer>) const =0; + virtual void on_subscribe(observer) const =0; virtual std::vector messages() const =0; virtual std::vector subscriptions() const =0; }; template -struct test_source +struct test_source : public rxs::source_base { explicit test_source(typename test_subject_base::type ts) @@ -32,11 +32,11 @@ struct test_source { } typename test_subject_base::type ts; - void on_subscribe(observer> o) const { + void on_subscribe(observer o) const { ts->on_subscribe(std::move(o)); } template - typename std::enable_if::type, observer>>::value, void>::type + typename std::enable_if::type, observer>::value, void>::type on_subscribe(Observer o) const { auto so = std::make_shared(o); ts->on_subscribe(make_observer_dynamic( @@ -59,17 +59,17 @@ struct test_source } template -class testable_observer - : public observer> +class testable_observer + : public observer { - typedef observer> observer_base; + typedef observer observer_base; typedef typename detail::test_subject_base::type test_subject; test_subject ts; public: typedef typename detail::test_subject_base::recorded_type recorded_type; - testable_observer(test_subject ts, observer_base ob) + testable_observer(test_subject ts, observer_base ob) : observer_base(std::move(ob)) , ts(std::move(ts)) { @@ -81,7 +81,7 @@ public: }; template -class testable_observable +class testable_observable : public observable> { typedef observable> observable_base; @@ -91,7 +91,7 @@ class testable_observable public: typedef typename detail::test_subject_base::recorded_type recorded_type; - explicit testable_observable(test_subject ts) + explicit testable_observable(test_subject ts) : observable_base(detail::test_source(ts)) , ts(ts) { @@ -113,4 +113,4 @@ namespace rxt=test; #include "schedulers/rx-test.hpp" -#endif \ No newline at end of file +#endif diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 8e0e9c9..8b833ad 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -117,7 +117,7 @@ public: // // performs type-forgetting conversion // - observable> as_dynamic() { + observable as_dynamic() { return *this; } diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp b/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp index 39cd0af..250dbf6 100644 --- a/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp @@ -175,7 +175,7 @@ public: typename test::shared sc; std::vector m; - virtual void on_subscribe(observer>) const { + virtual void on_subscribe(observer) const { abort(); } virtual std::vector subscriptions() const { @@ -242,7 +242,7 @@ public: { } - virtual void on_subscribe(observer> o) const { + virtual void on_subscribe(observer o) const { sv.push_back(rxn::subscription(sc->clock())); auto index = sv.size() - 1; @@ -283,7 +283,7 @@ class hot_observable typedef hot_observable this_type; typename test::shared sc; typedef rxn::recorded::type> recorded_type; - typedef observer> observer_type; + typedef observer observer_type; mutable std::vector mv; mutable std::vector sv; mutable std::vector observers; -- GitLab From fce5aed33fa96696f1be3974d4a674a05f5db80b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Mon, 17 Feb 2014 00:27:35 -0800 Subject: [PATCH 200/782] added optimized subject --- Rx/CPP/src/rxcpp/rx-includes.hpp | 2 + Rx/CPP/src/rxcpp/rx-observable.hpp | 181 ++++++++++++++++ Rx/CPP/src/rxcpp/rx-observer.hpp | 35 ++- Rx/CPP/src/rxcpp/rx-operators.hpp | 3 +- Rx/CPP/src/rxcpp/rx-predef.hpp | 3 +- Rx/CPP/src/rxcpp/rx-sources.hpp | 31 ++- Rx/CPP/src/rxcpp/rx-subjects.hpp | 21 ++ Rx/CPP/src/rxcpp/rx.hpp | 171 --------------- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 264 +++++++++++++++++++++++ Rx/CPP/test/v2/operators/filter.cpp | 48 +++++ 10 files changed, 567 insertions(+), 192 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/rx-observable.hpp create mode 100644 Rx/CPP/src/rxcpp/rx-subjects.hpp create mode 100644 Rx/CPP/src/rxcpp/subjects/rx-subject.hpp diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index 52c2283..7b53b15 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -96,7 +96,9 @@ #include "rx-notification.hpp" #include "rx-scheduler.hpp" #include "rx-sources.hpp" +#include "rx-subjects.hpp" #include "rx-operators.hpp" +#include "rx-observable.hpp" #pragma pop_macro("min") #pragma pop_macro("max") diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp new file mode 100644 index 0000000..fb7f8e1 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -0,0 +1,181 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_OBSERVABLE_HPP) +#define RXCPP_RX_SCHEDULER_OBSERVABLE_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +template +class observable +{ + mutable SourceOperator source_operator; + +private: + template + friend class observable; + + template + auto detail_subscribe(observer o, tag_observer&&) const + -> decltype(make_subscription(o)) { + + if (!o.is_subscribed()) { + return make_subscription(o); + } + + auto subscriber = [=]() { + try { + source_operator.on_subscribe(o); + } + catch(...) { + if (!o.is_subscribed()) { + throw; + } + o.on_error(std::current_exception()); + o.unsubscribe(); + } + }; + + if (rxsc::current_thread::is_schedule_required()) { + auto sc = rxsc::make_current_thread(); + sc->schedule([=](rxsc::action, rxsc::scheduler) { + subscriber(); + return rxsc::make_action_empty(); + }); + } else { + subscriber(); + } + + return make_subscription(o); + } + + struct tag_function {}; + template + auto detail_subscribe(OnNext n, tag_function&&) const + -> decltype(make_subscription( make_observer(std::move(n)))) { + return subscribe( make_observer(std::move(n))); + } + + template + auto detail_subscribe(OnNext n, OnError e, tag_function&&) const + -> decltype(make_subscription( make_observer(std::move(n), std::move(e)))) { + return subscribe( make_observer(std::move(n), std::move(e))); + } + + template + auto detail_subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) const + -> decltype(make_subscription( make_observer(std::move(n), std::move(e), std::move(c)))) { + return subscribe( make_observer(std::move(n), std::move(e), std::move(c))); + } + + template + auto detail_subscribe(composite_subscription cs, OnNext n, tag_subscription&&) const + -> decltype(make_subscription( make_observer(std::move(cs), std::move(n)))) { + return subscribe( make_observer(std::move(cs), std::move(n))); + } + + template + auto detail_subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) const + -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e)))) { + return subscribe( make_observer(std::move(cs), std::move(n), std::move(e))); + } + +public: + typedef T value_type; + + static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); + + observable() + { + } + + explicit observable(const SourceOperator& o) + : source_operator(o) + { + } + explicit observable(SourceOperator&& o) + : source_operator(std::move(o)) + { + } + + // implicit conversion between observables of the same value_type + template + observable(const observable& o) + : source_operator(o.source_operator) + {} + +#if 0 + template + void on_subscribe(observer o) const { + source_operator.on_subscribe(o); + } +#endif + + // + // performs type-forgetting conversion + // + observable as_dynamic() { + return *this; + } + + template + auto subscribe(Arg a) const + -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type())) { + return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type()); + } + + template + auto subscribe(Arg1 a1, Arg2 a2) const + -> decltype(detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type())) { + return detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type()); + } + + template + auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) const + -> decltype(detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type())) { + return detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type()); + } + + template + auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) const + -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c)))) { + return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); + } + +#if RXCPP_USE_OBSERVABLE_MEMBERS + template + auto filter(Predicate p) const + -> observable> { + return observable>( + rxo::detail::filter(*this, std::move(p))); + } +#endif +}; + +// observable<> has static methods to construct observable sources and adaptors. +// observable<> is not constructable +template<> +class observable +{ + ~observable(); +public: + template + static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable> { + return observable>( + rxs::detail::range(start, count, step, sc)); + } +}; + +} + +template +auto operator >> (rxcpp::observable source, OperatorFactory&& op) + -> decltype(op(source)){ + return op(source); +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index 976d6fc..c0d8ee2 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -27,8 +27,10 @@ private: mutable typename this_type::subscription_type s; - observer_base(); public: + observer_base() + { + } observer_base(typename this_type::subscription_type s) : s(std::move(s)) { @@ -237,6 +239,21 @@ class observer : public observer_root typedef observer this_type; typedef typename std::conditional::value, I, dynamic_observer>::type inner_t; + struct detacher + { + ~detacher() + { + if (that) { + that->unsubscribe(); + } + } + detacher(const observer* that) + : that(that) + { + } + const observer* that; + }; + inner_t inner; public: ~observer() @@ -248,28 +265,24 @@ public: } void on_next(T t) const { if (is_subscribed()) { - RXCPP_UNWIND(unsubscriber, [this](){ - this->unsubscribe(); - }); + detacher protect(this); inner.on_next(std::move(t)); - unsubscriber.dismiss(); + protect.that = nullptr; } } void on_error(std::exception_ptr e) const { if (is_subscribed()) { - RXCPP_UNWIND_AUTO([this](){ - this->unsubscribe(); - }); + detacher protect(this); inner.on_error(e); + protect.that = nullptr; } unsubscribe(); } void on_completed() const { if (is_subscribed()) { - RXCPP_UNWIND_AUTO([this](){ - this->unsubscribe(); - }); + detacher protect(this); inner.on_completed(); + protect.that = nullptr; } unsubscribe(); } diff --git a/Rx/CPP/src/rxcpp/rx-operators.hpp b/Rx/CPP/src/rxcpp/rx-operators.hpp index 519c136..497cb6f 100644 --- a/Rx/CPP/src/rxcpp/rx-operators.hpp +++ b/Rx/CPP/src/rxcpp/rx-operators.hpp @@ -11,7 +11,6 @@ namespace rxcpp { namespace operators { - struct tag_operator {}; template struct operator_base @@ -27,7 +26,7 @@ class is_operator template static void check(...); public: - static const bool value = std::is_convertible(0)), tag_operator>::value; + static const bool value = std::is_convertible::type>(0)), tag_operator>::value; }; } diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/CPP/src/rxcpp/rx-predef.hpp index 8da4f9f..9c32656 100644 --- a/Rx/CPP/src/rxcpp/rx-predef.hpp +++ b/Rx/CPP/src/rxcpp/rx-predef.hpp @@ -16,7 +16,7 @@ template> class observer; template -struct dynamic_observable; +class dynamic_observable; template< class T = void, @@ -24,7 +24,6 @@ template< void, dynamic_observable>::type> class observable; - } #endif diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp index a732178..d3126bd 100644 --- a/Rx/CPP/src/rxcpp/rx-sources.hpp +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -34,7 +34,7 @@ public: namespace rxs=sources; template -struct dynamic_observable +class dynamic_observable : public rxs::source_base { struct state_type @@ -46,17 +46,31 @@ struct dynamic_observable }; std::shared_ptr state; + template + void construct(SO so, rxs::tag_source&&) { + state->on_subscribe = [so](observer o) mutable { + so.on_subscribe(std::move(o)); + }; + } + + struct tag_function {}; + template + void construct(F&& f, tag_function&&) { + state->on_subscribe = std::forward(f); + } + +public: + dynamic_observable() { } - template - explicit dynamic_observable(Source source) + template + explicit dynamic_observable(SOF&& sof) : state(std::make_shared()) { - state->on_subscribe = [source](observer o) mutable { - source.on_subscribe(std::move(o)); - }; + construct(std::forward(sof), + typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type()); } void on_subscribe(observer o) const { @@ -84,6 +98,11 @@ struct dynamic_observable } }; +template +observable make_dynamic_observable(Source&& s) { + return observable(dynamic_observable(std::forward(s))); +} + } #include "sources/rx-range.hpp" diff --git a/Rx/CPP/src/rxcpp/rx-subjects.hpp b/Rx/CPP/src/rxcpp/rx-subjects.hpp new file mode 100644 index 0000000..1289835 --- /dev/null +++ b/Rx/CPP/src/rxcpp/rx-subjects.hpp @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_SUBJECTS_HPP) +#define RXCPP_RX_SCHEDULER_SUBJECTS_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace subjects { + +} +namespace rxsub=subjects; + +} + +#include "subjects/rx-subject.hpp" + +#endif \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/CPP/src/rxcpp/rx.hpp index 8b833ad..79bd4fd 100644 --- a/Rx/CPP/src/rxcpp/rx.hpp +++ b/Rx/CPP/src/rxcpp/rx.hpp @@ -7,175 +7,4 @@ #include "rx-includes.hpp" -namespace rxcpp { - -template -class observable -{ - mutable SourceOperator source_operator; - -private: - template - friend class observable; - - template - auto detail_subscribe(observer o, tag_observer&&) const - -> decltype(make_subscription(o)) { - - if (!o.is_subscribed()) { - return make_subscription(o); - } - - auto subscriber = [=]() { - try { - source_operator.on_subscribe(o); - } - catch(...) { - if (!o.is_subscribed()) { - throw; - } - o.on_error(std::current_exception()); - o.unsubscribe(); - } - }; - - if (rxsc::current_thread::is_schedule_required()) { - auto sc = rxsc::make_current_thread(); - sc->schedule([=](rxsc::action, rxsc::scheduler) { - subscriber(); - return rxsc::make_action_empty(); - }); - } else { - subscriber(); - } - - return make_subscription(o); - } - - struct tag_function {}; - template - auto detail_subscribe(OnNext n, tag_function&&) const - -> decltype(make_subscription( make_observer(std::move(n)))) { - return subscribe( make_observer(std::move(n))); - } - - template - auto detail_subscribe(OnNext n, OnError e, tag_function&&) const - -> decltype(make_subscription( make_observer(std::move(n), std::move(e)))) { - return subscribe( make_observer(std::move(n), std::move(e))); - } - - template - auto detail_subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) const - -> decltype(make_subscription( make_observer(std::move(n), std::move(e), std::move(c)))) { - return subscribe( make_observer(std::move(n), std::move(e), std::move(c))); - } - - template - auto detail_subscribe(composite_subscription cs, OnNext n, tag_subscription&&) const - -> decltype(make_subscription( make_observer(std::move(cs), std::move(n)))) { - return subscribe( make_observer(std::move(cs), std::move(n))); - } - - template - auto detail_subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) const - -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e)))) { - return subscribe( make_observer(std::move(cs), std::move(n), std::move(e))); - } - -public: - typedef T value_type; - - static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); - - observable() - { - } - - explicit observable(const SourceOperator& o) - : source_operator(o) - { - } - explicit observable(SourceOperator&& o) - : source_operator(std::move(o)) - { - } - - // implicit conversion between observables of the same value_type - template - observable(const observable& o) - : source_operator(o.source_operator) - {} - -#if 0 - template - void on_subscribe(observer o) const { - source_operator.on_subscribe(o); - } -#endif - - // - // performs type-forgetting conversion - // - observable as_dynamic() { - return *this; - } - - template - auto subscribe(Arg a) const - -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type())) { - return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type()); - } - - template - auto subscribe(Arg1 a1, Arg2 a2) const - -> decltype(detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type())) { - return detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type()); - } - - template - auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) const - -> decltype(detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type())) { - return detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type()); - } - - template - auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) const - -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c)))) { - return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); - } - -#if RXCPP_USE_OBSERVABLE_MEMBERS - template - auto filter(Predicate p) const - -> observable> { - return observable>( - rxo::detail::filter(*this, std::move(p))); - } -#endif -}; - -// observable<> has static methods to construct observable sources and adaptors. -// observable<> is not constructable -template<> -class observable -{ - ~observable(); -public: - template - static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable> { - return observable>( - rxs::detail::range(start, count, step, sc)); - } -}; - -} - -template -auto operator >> (rxcpp::observable source, OperatorFactory&& op) - -> decltype(op(source)){ - return op(source); -} - #endif diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp new file mode 100644 index 0000000..435e1db --- /dev/null +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -0,0 +1,264 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_SUBJECT_HPP) +#define RXCPP_RX_SCHEDULER_SUBJECT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace subjects { + +namespace detail { + + +template +class multicast_observer + : public observer_base +{ + typedef observer_base base; + typedef std::vector> list_type; + + struct state_type; + + struct machine_type + { + ~machine_type() + { + delete state.exchange(nullptr); + } + machine_type(std::unique_ptr state) + : state(state.release()) + { + } + mutable std::recursive_mutex replace_lock; + mutable std::atomic state; + }; + + struct state_type + { + virtual void spin_until_unused() const =0; + virtual void add(observer observer, machine_type& m) const =0; + virtual void on_next(T t, machine_type& m) const =0; + virtual void on_error(std::exception_ptr e, machine_type& m) const =0; + virtual void on_completed(machine_type& m) const =0; + }; + + struct errored + : public state_type + { + std::exception_ptr e; + errored(std::exception_ptr e) + : e(e) + { + } + virtual void spin_until_unused() const { + } + virtual void add(observer observer, machine_type&) const { + observer.on_error(e); + } + virtual void on_next(T, machine_type&) const { + } + virtual void on_error(std::exception_ptr, machine_type&) const { + } + virtual void on_completed(machine_type&) const { + } + }; + + struct completed + : public state_type + { + virtual void spin_until_unused() const { + } + virtual void add(observer observer, machine_type&) const { + observer.on_completed(); + } + virtual void on_next(T, machine_type&) const { + } + virtual void on_error(std::exception_ptr, machine_type&) const { + } + virtual void on_completed(machine_type&) const { + } + }; + + struct casting + : public state_type + { + mutable std::atomic count; + mutable list_type observers; + + struct scoped_count + { + std::atomic& c; + ~scoped_count() + { + --c; + } + scoped_count(std::atomic& c) + : c(c) + { + ++c; + } + }; + + casting(list_type existing, observer observer) + : observers(existing) + { + observers.push_back(observer); + } + + virtual void spin_until_unused() const { + while(count != 0); + } + virtual void add(observer observer, machine_type& m) const { + std::unique_ptr that; + { + scoped_count track(count); + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new casting(observers, observer)); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->add(observer, m); + return; + } + that.reset(compare); + next.release(); + } + that->spin_until_unused(); + } + virtual void on_next(T t, machine_type& m) const { + scoped_count track(count); + for (auto& o : observers) { + o.on_next(std::move(t)); + } + } + virtual void on_error(std::exception_ptr e, machine_type& m) const { + std::unique_ptr that; + { + scoped_count track(count); + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new errored(e)); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->on_error(e, m); + return; + } + that.reset(compare); + next.release(); + guard.unlock(); + for (auto& o : observers) { + o.on_error(std::move(e)); + } + } + that->spin_until_unused(); + } + virtual void on_completed(machine_type& m) const { + std::unique_ptr that; + { + scoped_count track(count); + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new completed()); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->on_completed(m); + return; + } + that.reset(compare); + next.release(); + guard.unlock(); + for (auto& o : observers) { + o.on_completed(); + } + } + that->spin_until_unused(); + } + }; + + struct empty + : public state_type + { + virtual void spin_until_unused() const { + } + virtual void add(observer observer, machine_type& m) const { + list_type none; + std::unique_ptr that; + { + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new casting(none, observer)); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->add(observer, m); + return; + } + that.reset(compare); + next.release(); + } + } + virtual void on_next(T, machine_type&) const { + } + virtual void on_error(std::exception_ptr, machine_type&) const { + } + virtual void on_completed(machine_type&) const { + } + }; + + typedef std::shared_ptr shared; + shared machine; + +public: + multicast_observer() + : machine(std::make_shared(std::unique_ptr(new empty()))) + { + } + multicast_observer(composite_subscription cs) + : observer_base(std::move(cs)) + , machine(std::make_shared(std::unique_ptr(new empty()))) + { + } + void add(observer observer) const { + machine->state.load()->add(observer, *machine); + } + void on_next(T t) const { + machine->state.load()->on_next(std::move(t), *machine); + } + void on_error(std::exception_ptr e) const { + machine->state.load()->on_error(std::move(e), *machine); + } + void on_completed() const { + machine->state.load()->on_completed(*machine); + } +}; + +} + +template +class subject +{ + detail::multicast_observer s; + +public: + subject() + { + } + subject(composite_subscription cs) + : s(std::move(cs)) + { + } + + observer> get_observer() const { + return observer>(s); + } + observable get_observable() const { + return make_dynamic_observable([this](observer o){ + this->s.add(std::move(o)); + }); + } +}; + +} + +} + +#endif \ No newline at end of file diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index cd2fdf6..03140a9 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -7,6 +7,7 @@ namespace rxu=rxcpp::util; namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" @@ -27,6 +28,53 @@ bool IsPrime(int x) } } +SCENARIO("subject test", "[subject][subjects]"){ + GIVEN("a subject"){ + WHEN("multicasting a million ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + const int onnextcalls = 10000000; + + for (int n = 0; n < 10; n++) + { + rxsub::subject sub; + + for (int i = 0; i < n; i++) { + sub.get_observable().subscribe([](int){}); + } + + auto start = clock::now(); + rxs::range(0, onnextcalls).subscribe(sub.get_observer()); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "range: " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + for (int n = 0; n < 10; n++) + { + rxsub::subject sub; + + for (int i = 0; i < n; i++) { + sub.get_observable().subscribe([](int){}); + } + + auto start = clock::now(); + auto o = sub.get_observer(); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); + } + o.on_completed(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop : " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } + } +} + SCENARIO("filter stops on completion", "[filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); -- GitLab From 9899e4202c6533ccc0ed97ef08bd59bee952e1b5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 17 Feb 2014 00:43:06 -0800 Subject: [PATCH 201/782] making clang happy --- Rx/CPP/src/rxcpp/rx-observable.hpp | 72 +++++++++++++++++++++++- Rx/CPP/src/rxcpp/rx-predef.hpp | 3 + Rx/CPP/src/rxcpp/rx-sources.hpp | 70 ----------------------- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 5 +- Rx/CPP/test/v2/operators/filter.cpp | 17 +++--- 5 files changed, 86 insertions(+), 81 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp index fb7f8e1..0e520c4 100644 --- a/Rx/CPP/src/rxcpp/rx-observable.hpp +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -9,6 +9,76 @@ namespace rxcpp { +template +class dynamic_observable + : public rxs::source_base +{ + struct state_type + : public std::enable_shared_from_this + { + typedef std::function)> onsubscribe_type; + + onsubscribe_type on_subscribe; + }; + std::shared_ptr state; + + template + void construct(SO so, rxs::tag_source&&) { + state->on_subscribe = [so](observer o) mutable { + so.on_subscribe(std::move(o)); + }; + } + + struct tag_function {}; + template + void construct(F&& f, tag_function&&) { + state->on_subscribe = std::forward(f); + } + +public: + + dynamic_observable() + { + } + + template + explicit dynamic_observable(SOF&& sof) + : state(std::make_shared()) + { + construct(std::forward(sof), + typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type()); + } + + void on_subscribe(observer o) const { + state->on_subscribe(std::move(o)); + } + + template + typename std::enable_if::type, observer>::value, void>::type + on_subscribe(Observer o) const { + auto so = std::make_shared(o); + state->on_subscribe(make_observer_dynamic( + so->get_subscription(), + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + })); + } +}; + +template +observable make_dynamic_observable(Source&& s) { + return observable(dynamic_observable(std::forward(s))); +} + template class observable { @@ -178,4 +248,4 @@ auto operator >> (rxcpp::observable source, OperatorFactory&& return op(source); } -#endif \ No newline at end of file +#endif diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/CPP/src/rxcpp/rx-predef.hpp index 9c32656..588f2d2 100644 --- a/Rx/CPP/src/rxcpp/rx-predef.hpp +++ b/Rx/CPP/src/rxcpp/rx-predef.hpp @@ -24,6 +24,9 @@ template< void, dynamic_observable>::type> class observable; +template +observable make_dynamic_observable(Source&&); + } #endif diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/CPP/src/rxcpp/rx-sources.hpp index d3126bd..7e585a1 100644 --- a/Rx/CPP/src/rxcpp/rx-sources.hpp +++ b/Rx/CPP/src/rxcpp/rx-sources.hpp @@ -33,76 +33,6 @@ public: } namespace rxs=sources; -template -class dynamic_observable - : public rxs::source_base -{ - struct state_type - : public std::enable_shared_from_this - { - typedef std::function)> onsubscribe_type; - - onsubscribe_type on_subscribe; - }; - std::shared_ptr state; - - template - void construct(SO so, rxs::tag_source&&) { - state->on_subscribe = [so](observer o) mutable { - so.on_subscribe(std::move(o)); - }; - } - - struct tag_function {}; - template - void construct(F&& f, tag_function&&) { - state->on_subscribe = std::forward(f); - } - -public: - - dynamic_observable() - { - } - - template - explicit dynamic_observable(SOF&& sof) - : state(std::make_shared()) - { - construct(std::forward(sof), - typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type()); - } - - void on_subscribe(observer o) const { - state->on_subscribe(std::move(o)); - } - - template - typename std::enable_if::type, observer>::value, void>::type - on_subscribe(Observer o) const { - auto so = std::make_shared(o); - state->on_subscribe(make_observer_dynamic( - so->get_subscription(), - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - })); - } -}; - -template -observable make_dynamic_observable(Source&& s) { - return observable(dynamic_observable(std::forward(s))); -} - } #include "sources/rx-range.hpp" diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index 435e1db..1128307 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -39,6 +39,7 @@ class multicast_observer struct state_type { + virtual ~state_type(){} virtual void spin_until_unused() const =0; virtual void add(observer observer, machine_type& m) const =0; virtual void on_next(T t, machine_type& m) const =0; @@ -103,7 +104,7 @@ class multicast_observer } }; - casting(list_type existing, observer observer) + casting(list_type existing, observer observer) : observers(existing) { observers.push_back(observer); @@ -261,4 +262,4 @@ public: } -#endif \ No newline at end of file +#endif diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 03140a9..1d6aa9b 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -45,11 +45,15 @@ SCENARIO("subject test", "[subject][subjects]"){ } auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe(sub.get_observer()); + auto o = sub.get_observer(); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); + } + o.on_completed(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "range: " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop : " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } for (int n = 0; n < 10; n++) @@ -61,16 +65,13 @@ SCENARIO("subject test", "[subject][subjects]"){ } auto start = clock::now(); - auto o = sub.get_observer(); - for (int i = 0; i < onnextcalls; i++) { - o.on_next(i); - } - o.on_completed(); + rxs::range(0, onnextcalls).subscribe(sub.get_observer()); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "loop : " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "range: " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } + } } } -- GitLab From 9307e99bf3781755e4ae261cdc187892706cf2a3 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Mon, 17 Feb 2014 07:35:20 -0800 Subject: [PATCH 202/782] async changes --- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 120 ++++++++++------------- Rx/CPP/test/v2/operators/filter.cpp | 7 +- 2 files changed, 59 insertions(+), 68 deletions(-) diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index 1128307..d280a4d 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -40,7 +40,6 @@ class multicast_observer struct state_type { virtual ~state_type(){} - virtual void spin_until_unused() const =0; virtual void add(observer observer, machine_type& m) const =0; virtual void on_next(T t, machine_type& m) const =0; virtual void on_error(std::exception_ptr e, machine_type& m) const =0; @@ -55,8 +54,6 @@ class multicast_observer : e(e) { } - virtual void spin_until_unused() const { - } virtual void add(observer observer, machine_type&) const { observer.on_error(e); } @@ -71,8 +68,6 @@ class multicast_observer struct completed : public state_type { - virtual void spin_until_unused() const { - } virtual void add(observer observer, machine_type&) const { observer.on_completed(); } @@ -89,99 +84,92 @@ class multicast_observer { mutable std::atomic count; mutable list_type observers; + mutable std::unique_ptr that; + struct scoped_count { - std::atomic& c; + const casting& c; ~scoped_count() { - --c; + if (--c.count == 0) { + c.that.reset(); + } } - scoped_count(std::atomic& c) - : c(c) + scoped_count(const casting* c) + : c(*c) { - ++c; + ++this->c.count; } }; - casting(list_type existing, observer observer) - : observers(existing) + casting(list_type& existing, observer o) { - observers.push_back(observer); + observers.reserve(existing.size() + 1); + std::copy_if( + existing.begin(), existing.end(), + std::inserter(observers, observers.end()), + [](observer& o){ + return o.is_subscribed(); + }); + observers.push_back(o); } - virtual void spin_until_unused() const { - while(count != 0); - } virtual void add(observer observer, machine_type& m) const { - std::unique_ptr that; - { - scoped_count track(count); - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new casting(observers, observer)); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->add(observer, m); - return; - } - that.reset(compare); - next.release(); + scoped_count track(this); + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new casting(observers, observer)); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->add(observer, m); + return; } - that->spin_until_unused(); + that.reset(compare); + next.release(); } virtual void on_next(T t, machine_type& m) const { - scoped_count track(count); + scoped_count track(this); for (auto& o : observers) { o.on_next(std::move(t)); } } virtual void on_error(std::exception_ptr e, machine_type& m) const { - std::unique_ptr that; - { - scoped_count track(count); - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new errored(e)); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->on_error(e, m); - return; - } - that.reset(compare); - next.release(); - guard.unlock(); - for (auto& o : observers) { - o.on_error(std::move(e)); - } + scoped_count track(this); + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new errored(e)); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->on_error(e, m); + return; + } + that.reset(compare); + next.release(); + guard.unlock(); + for (auto& o : observers) { + o.on_error(std::move(e)); } - that->spin_until_unused(); } virtual void on_completed(machine_type& m) const { - std::unique_ptr that; - { - scoped_count track(count); - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new completed()); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->on_completed(m); - return; - } - that.reset(compare); - next.release(); - guard.unlock(); - for (auto& o : observers) { - o.on_completed(); - } + scoped_count track(this); + std::unique_lock guard(m.replace_lock); + std::unique_ptr next(new completed()); + state_type* compare = const_cast(this); + if (!m.state.compare_exchange_strong(compare, next.get())) { + compare->on_completed(m); + return; + } + that.reset(compare); + next.release(); + guard.unlock(); + for (auto& o : observers) { + o.on_completed(); } - that->spin_until_unused(); } }; struct empty : public state_type { - virtual void spin_until_unused() const { - } virtual void add(observer observer, machine_type& m) const { list_type none; std::unique_ptr that; diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 1d6aa9b..59e1d00 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -44,8 +44,9 @@ SCENARIO("subject test", "[subject][subjects]"){ sub.get_observable().subscribe([](int){}); } - auto start = clock::now(); auto o = sub.get_observer(); + + auto start = clock::now(); for (int i = 0; i < onnextcalls; i++) { o.on_next(i); } @@ -64,8 +65,10 @@ SCENARIO("subject test", "[subject][subjects]"){ sub.get_observable().subscribe([](int){}); } + auto o = sub.get_observer(); + auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe(sub.get_observer()); + rxs::range(0, onnextcalls).subscribe(o); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); -- GitLab From b7734f43a9921793bc2538dc33222882ea85bb78 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 18 Feb 2014 17:37:41 -0800 Subject: [PATCH 203/782] new subject impl I have to choose correct and simple over fast and wrong. The std::recursive_mutex perf controls the perf in this impl. --- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 280 ++++++++++------------- Rx/CPP/test/v2/operators/filter.cpp | 84 ++++++- 2 files changed, 197 insertions(+), 167 deletions(-) diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index d280a4d..7358212 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -13,213 +13,171 @@ namespace subjects { namespace detail { - template class multicast_observer : public observer_base { typedef observer_base base; - typedef std::vector> list_type; - - struct state_type; + typedef observer observer_type; + typedef std::vector list_type; - struct machine_type + struct mode { - ~machine_type() - { - delete state.exchange(nullptr); - } - machine_type(std::unique_ptr state) - : state(state.release()) - { - } - mutable std::recursive_mutex replace_lock; - mutable std::atomic state; + enum type { + Invalid = 0, + Casting, + Completed, + Errored + }; }; - struct state_type - { - virtual ~state_type(){} - virtual void add(observer observer, machine_type& m) const =0; - virtual void on_next(T t, machine_type& m) const =0; - virtual void on_error(std::exception_ptr e, machine_type& m) const =0; - virtual void on_completed(machine_type& m) const =0; - }; + struct completer_type; - struct errored - : public state_type + struct state_type + : public std::enable_shared_from_this { - std::exception_ptr e; - errored(std::exception_ptr e) - : e(e) + state_type() + : current(mode::Casting) { } - virtual void add(observer observer, machine_type&) const { - observer.on_error(e); - } - virtual void on_next(T, machine_type&) const { - } - virtual void on_error(std::exception_ptr, machine_type&) const { - } - virtual void on_completed(machine_type&) const { - } + std::atomic completers; + std::recursive_mutex lock; + typename mode::type current; + std::exception_ptr error; }; - struct completed - : public state_type + struct completer_type + : public std::enable_shared_from_this { - virtual void add(observer observer, machine_type&) const { - observer.on_completed(); - } - virtual void on_next(T, machine_type&) const { - } - virtual void on_error(std::exception_ptr, machine_type&) const { - } - virtual void on_completed(machine_type&) const { - } - }; - - struct casting - : public state_type - { - mutable std::atomic count; - mutable list_type observers; - mutable std::unique_ptr that; - - - struct scoped_count + ~completer_type() { - const casting& c; - ~scoped_count() - { - if (--c.count == 0) { - c.that.reset(); + std::unique_lock guard(state->lock); + if (--state->completers == 0) { + switch(state->current) { + case mode::Casting: + break; + case mode::Errored: + { + for (auto& o : observers) { + o.on_error(state->error); + } + } + break; + case mode::Completed: + { + for (auto& o : observers) { + o.on_completed(); + } + } + break; + default: + abort(); } } - scoped_count(const casting* c) - : c(*c) - { - ++this->c.count; - } - }; - - casting(list_type& existing, observer o) - { - observers.reserve(existing.size() + 1); - std::copy_if( - existing.begin(), existing.end(), - std::inserter(observers, observers.end()), - [](observer& o){ - return o.is_subscribed(); - }); - observers.push_back(o); - } - - virtual void add(observer observer, machine_type& m) const { - scoped_count track(this); - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new casting(observers, observer)); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->add(observer, m); - return; - } - that.reset(compare); - next.release(); - } - virtual void on_next(T t, machine_type& m) const { - scoped_count track(this); - for (auto& o : observers) { - o.on_next(std::move(t)); - } } - virtual void on_error(std::exception_ptr e, machine_type& m) const { - scoped_count track(this); - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new errored(e)); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->on_error(e, m); - return; - } - that.reset(compare); - next.release(); - guard.unlock(); - for (auto& o : observers) { - o.on_error(std::move(e)); - } - } - virtual void on_completed(machine_type& m) const { - scoped_count track(this); - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new completed()); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->on_completed(m); - return; - } - that.reset(compare); - next.release(); - guard.unlock(); - for (auto& o : observers) { - o.on_completed(); + completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) + : state(s) + { + ++state->completers; + if (old) { + observers.reserve(old->observers.size() + 1); + std::copy_if( + old->observers.begin(), old->observers.end(), + std::inserter(observers, observers.end()), + [](const observer& o){ + return o.is_subscribed(); + }); } + observers.push_back(o); } + std::shared_ptr state; + list_type observers; }; - struct empty - : public state_type + // this type exists to prevent a circular ref between state and completer + struct binder_type + : public std::enable_shared_from_this { - virtual void add(observer observer, machine_type& m) const { - list_type none; - std::unique_ptr that; - { - std::unique_lock guard(m.replace_lock); - std::unique_ptr next(new casting(none, observer)); - state_type* compare = const_cast(this); - if (!m.state.compare_exchange_strong(compare, next.get())) { - compare->add(observer, m); - return; - } - that.reset(compare); - next.release(); - } - } - virtual void on_next(T, machine_type&) const { - } - virtual void on_error(std::exception_ptr, machine_type&) const { - } - virtual void on_completed(machine_type&) const { + binder_type() + : state(std::make_shared()) + { } + + std::shared_ptr state; + + // must only be accessed under state->lock + mutable std::shared_ptr completer; }; - typedef std::shared_ptr shared; - shared machine; + std::shared_ptr b; + + public: multicast_observer() - : machine(std::make_shared(std::unique_ptr(new empty()))) + : b(std::make_shared()) { } multicast_observer(composite_subscription cs) : observer_base(std::move(cs)) - , machine(std::make_shared(std::unique_ptr(new empty()))) + , b(std::make_shared()) { } - void add(observer observer) const { - machine->state.load()->add(observer, *machine); + void add(observer o) const { + std::unique_lock guard(b->state->lock); + switch (b->state->current) { + case mode::Casting: + { + if (o.is_subscribed()) { + b->completer = std::make_shared(b->state, b->completer, o); + } + } + break; + case mode::Completed: + { + o.on_completed(); + } + break; + case mode::Errored: + { + o.on_error(b->state->error); + } + break; + default: + abort(); + } } void on_next(T t) const { - machine->state.load()->on_next(std::move(t), *machine); + std::shared_ptr c; + { + std::unique_lock guard(b->state->lock); + if (!b->completer) { + return; + } + c = b->completer; + } + for (auto& o : c->observers) { + o.on_next(std::move(t)); + } } void on_error(std::exception_ptr e) const { - machine->state.load()->on_error(std::move(e), *machine); + std::unique_lock guard(b->state->lock); + if (b->state->current == mode::Casting) { + b->state->error = e; + b->state->current = mode::Errored; + b->completer.reset(); + } } void on_completed() const { - machine->state.load()->on_completed(*machine); + std::unique_lock guard(b->state->lock); + if (b->state->current == mode::Casting) { + b->state->current = mode::Completed; + b->completer.reset(); + } } }; + } template diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 59e1d00..8a6c462 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,5 +1,6 @@ #define RXCPP_USE_OBSERVABLE_MEMBERS 1 +#define RXCPP_SUBJECT_TEST_ASYNC 0 #include "rxcpp/rx.hpp" namespace rx=rxcpp; @@ -34,14 +35,72 @@ SCENARIO("subject test", "[subject][subjects]"){ using namespace std::chrono; typedef steady_clock clock; - const int onnextcalls = 10000000; + const int onnextcalls = 100000000; + + { + int c = 0; + int n = 1; + auto o = rx::make_observer([&c](int){++c;}); + auto start = clock::now(); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); + } + o.on_completed(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + { + int c = 0; + int n = 1; + auto start = clock::now(); + rxs::range(0, onnextcalls).subscribe([&c](int){++c;}); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "range no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + { + std::recursive_mutex m; + int c = 0; + int n = 1; + auto start = clock::now(); + for (int i = 0; i < onnextcalls; i++) { + std::unique_lock guard(m); + ++c; + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop recursive_mutex: " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } for (int n = 0; n < 10; n++) { + auto c = std::make_shared(); rxsub::subject sub; for (int i = 0; i < n; i++) { - sub.get_observable().subscribe([](int){}); +#if RXCPP_SUBJECT_TEST_ASYNC + std::async([sub, c]() { + auto source = sub.get_observable(); + auto subscription = sub.get_observer(); + while(subscription.is_subscribed()) { + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + rx::composite_subscription cs; + assert(cs.is_subscribed()); + source.subscribe(cs, [c, cs](int){ + ++(*c); + cs.unsubscribe(); + }); + } + }); +#else + sub.get_observable().subscribe([c](int){++(*c);}); +#endif } auto o = sub.get_observer(); @@ -54,15 +113,29 @@ SCENARIO("subject test", "[subject][subjects]"){ auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "loop : " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } for (int n = 0; n < 10; n++) { + auto c = std::make_shared(); rxsub::subject sub; for (int i = 0; i < n; i++) { - sub.get_observable().subscribe([](int){}); +#if RXCPP_SUBJECT_TEST_ASYNC + std::async([sub, c]() { + while(sub.get_observer().is_subscribed()) { + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + rx::composite_subscription cs; + sub.get_observable().subscribe(cs, [c, cs](int){ + ++(*c); + cs.unsubscribe(); + }); + } + }); +#else + sub.get_observable().subscribe([c](int){++(*c);}); +#endif } auto o = sub.get_observer(); @@ -72,9 +145,8 @@ SCENARIO("subject test", "[subject][subjects]"){ auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "range: " << n << " subscribed, " << onnextcalls << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "range : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } - } } } -- GitLab From 68e866d9d9dd09b1f48b1b897700a6e347183389 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 18 Feb 2014 18:10:07 -0800 Subject: [PATCH 204/782] clang fixes --- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 8 ++++---- Rx/CPP/test/v2/operators/filter.cpp | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index 7358212..ab0b5bd 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -75,7 +75,7 @@ class multicast_observer } } } - completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) + completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) : state(s) { ++state->completers; @@ -106,7 +106,7 @@ class multicast_observer std::shared_ptr state; // must only be accessed under state->lock - mutable std::shared_ptr completer; + mutable std::shared_ptr completer; }; std::shared_ptr b; @@ -129,7 +129,7 @@ public: case mode::Casting: { if (o.is_subscribed()) { - b->completer = std::make_shared(b->state, b->completer, o); + b->completer = std::make_shared(b->state, b->completer, o); } } break; @@ -148,7 +148,7 @@ public: } } void on_next(T t) const { - std::shared_ptr c; + std::shared_ptr c; { std::unique_lock guard(b->state->lock); if (!b->completer) { diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 8a6c462..0a80897 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -80,7 +80,7 @@ SCENARIO("subject test", "[subject][subjects]"){ for (int n = 0; n < 10; n++) { - auto c = std::make_shared(); + auto c = std::make_shared(0); rxsub::subject sub; for (int i = 0; i < n; i++) { @@ -118,7 +118,7 @@ SCENARIO("subject test", "[subject][subjects]"){ for (int n = 0; n < 10; n++) { - auto c = std::make_shared(); + auto c = std::make_shared(0); rxsub::subject sub; for (int i = 0; i < n; i++) { -- GitLab From b24fdaba44891782c4a4f71f91d56ec83e9f7956 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 18 Feb 2014 18:39:39 -0800 Subject: [PATCH 205/782] fix async bug --- Rx/CPP/test/v2/operators/filter.cpp | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 0a80897..4d70651 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -35,7 +35,7 @@ SCENARIO("subject test", "[subject][subjects]"){ using namespace std::chrono; typedef steady_clock clock; - const int onnextcalls = 100000000; + const int onnextcalls = 10000000; { int c = 0; @@ -83,9 +83,13 @@ SCENARIO("subject test", "[subject][subjects]"){ auto c = std::make_shared(0); rxsub::subject sub; +#if RXCPP_SUBJECT_TEST_ASYNC + std::vector> f(n); +#endif + for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC - std::async([sub, c]() { + f[i] = std::async([sub, c]() { auto source = sub.get_observable(); auto subscription = sub.get_observer(); while(subscription.is_subscribed()) { @@ -97,6 +101,7 @@ SCENARIO("subject test", "[subject][subjects]"){ cs.unsubscribe(); }); } + return 0; }); #else sub.get_observable().subscribe([c](int){++(*c);}); @@ -121,9 +126,13 @@ SCENARIO("subject test", "[subject][subjects]"){ auto c = std::make_shared(0); rxsub::subject sub; +#if RXCPP_SUBJECT_TEST_ASYNC + std::vector> f(n); +#endif + for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC - std::async([sub, c]() { + f[i] = std::async([sub, c]() { while(sub.get_observer().is_subscribed()) { std::this_thread::sleep_for(std::chrono::milliseconds(50)); rx::composite_subscription cs; @@ -132,6 +141,7 @@ SCENARIO("subject test", "[subject][subjects]"){ cs.unsubscribe(); }); } + return 0; }); #else sub.get_observable().subscribe([c](int){++(*c);}); -- GitLab From 4185a6945b4712cf1083ea67888b005027724e31 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 18 Feb 2014 23:52:14 -0800 Subject: [PATCH 206/782] remove recursive_mutex usage --- Rx/CPP/src/rxcpp/rx-observable.hpp | 2 -- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 29 ++++++++++++++++-------- Rx/CPP/test/v2/operators/filter.cpp | 29 ++++++++++-------------- 3 files changed, 32 insertions(+), 28 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp index 0e520c4..7d201cf 100644 --- a/Rx/CPP/src/rxcpp/rx-observable.hpp +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -215,14 +215,12 @@ public: return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } -#if RXCPP_USE_OBSERVABLE_MEMBERS template auto filter(Predicate p) const -> observable> { return observable>( rxo::detail::filter(*this, std::move(p))); } -#endif }; // observable<> has static methods to construct observable sources and adaptors. diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index ab0b5bd..7c1c67f 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -41,7 +41,7 @@ class multicast_observer { } std::atomic completers; - std::recursive_mutex lock; + std::mutex lock; typename mode::type current; std::exception_ptr error; }; @@ -51,13 +51,14 @@ class multicast_observer { ~completer_type() { - std::unique_lock guard(state->lock); if (--state->completers == 0) { + std::unique_lock guard(state->lock); switch(state->current) { case mode::Casting: break; case mode::Errored: { + guard.unlock(); for (auto& o : observers) { o.on_error(state->error); } @@ -65,6 +66,7 @@ class multicast_observer break; case mode::Completed: { + guard.unlock(); for (auto& o : observers) { o.on_completed(); } @@ -124,7 +126,7 @@ public: { } void add(observer o) const { - std::unique_lock guard(b->state->lock); + std::unique_lock guard(b->state->lock); switch (b->state->current) { case mode::Casting: { @@ -135,12 +137,17 @@ public: break; case mode::Completed: { + guard.unlock(); o.on_completed(); + return; } break; case mode::Errored: { - o.on_error(b->state->error); + auto e = b->state->error; + guard.unlock(); + o.on_error(e); + return; } break; default: @@ -150,7 +157,7 @@ public: void on_next(T t) const { std::shared_ptr c; { - std::unique_lock guard(b->state->lock); + std::unique_lock guard(b->state->lock); if (!b->completer) { return; } @@ -161,18 +168,22 @@ public: } } void on_error(std::exception_ptr e) const { - std::unique_lock guard(b->state->lock); + std::unique_lock guard(b->state->lock); if (b->state->current == mode::Casting) { b->state->error = e; b->state->current = mode::Errored; - b->completer.reset(); + auto c = std::move(b->completer); + guard.unlock(); + // destruct completer outside the lock } } void on_completed() const { - std::unique_lock guard(b->state->lock); + std::unique_lock guard(b->state->lock); if (b->state->current == mode::Casting) { b->state->current = mode::Completed; - b->completer.reset(); + auto c = std::move(b->completer); + guard.unlock(); + // destruct completer outside the lock } } }; diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 4d70651..e188939 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,6 +1,6 @@ #define RXCPP_USE_OBSERVABLE_MEMBERS 1 -#define RXCPP_SUBJECT_TEST_ASYNC 0 +#define RXCPP_SUBJECT_TEST_ASYNC 1 #include "rxcpp/rx.hpp" namespace rx=rxcpp; @@ -64,18 +64,18 @@ SCENARIO("subject test", "[subject][subjects]"){ } { - std::recursive_mutex m; + std::mutex m; int c = 0; int n = 1; auto start = clock::now(); for (int i = 0; i < onnextcalls; i++) { - std::unique_lock guard(m); + std::unique_lock guard(m); ++c; } auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "loop recursive_mutex: " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } for (int n = 0; n < 10; n++) @@ -89,23 +89,20 @@ SCENARIO("subject test", "[subject][subjects]"){ for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC - f[i] = std::async([sub, c]() { + f[i] = std::async([sub]() { auto source = sub.get_observable(); auto subscription = sub.get_observer(); while(subscription.is_subscribed()) { - std::this_thread::sleep_for(std::chrono::milliseconds(50)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); rx::composite_subscription cs; - assert(cs.is_subscribed()); - source.subscribe(cs, [c, cs](int){ - ++(*c); + source.subscribe(cs, [cs](int){ cs.unsubscribe(); }); } return 0; }); -#else - sub.get_observable().subscribe([c](int){++(*c);}); #endif + sub.get_observable().subscribe([c](int){++(*c);}); } auto o = sub.get_observer(); @@ -132,20 +129,18 @@ SCENARIO("subject test", "[subject][subjects]"){ for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC - f[i] = std::async([sub, c]() { + f[i] = std::async([sub]() { while(sub.get_observer().is_subscribed()) { - std::this_thread::sleep_for(std::chrono::milliseconds(50)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); rx::composite_subscription cs; - sub.get_observable().subscribe(cs, [c, cs](int){ - ++(*c); + sub.get_observable().subscribe(cs, [cs](int){ cs.unsubscribe(); }); } return 0; }); -#else - sub.get_observable().subscribe([c](int){++(*c);}); #endif + sub.get_observable().subscribe([c](int){++(*c);}); } auto o = sub.get_observer(); -- GitLab From b60bf6bfe0321790ab94c44632d00bb68479e841 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 20 Feb 2014 21:55:38 -0800 Subject: [PATCH 207/782] give specific string to exception --- Rx/CPP/test/v2/operators/filter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index e188939..a69df05 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -316,7 +316,7 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ long invoked = 0; - std::exception ex; + std::exception ex("filter on_error from source"); auto xs = sc->make_hot_observable( [ex]() { @@ -401,7 +401,7 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ long invoked = 0; - std::exception ex; + std::exception ex("filter predicate error"); auto xs = sc->make_hot_observable( []() { -- GitLab From 39f1072f615f751454cf9e2be56ee96ce9cc5b16 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 20 Feb 2014 22:00:55 -0800 Subject: [PATCH 208/782] add static checking for observer functions --- Rx/CPP/src/rxcpp/rx-observer.hpp | 337 ++++++++++++++++++++++++++----- 1 file changed, 289 insertions(+), 48 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index c0d8ee2..968901b 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -87,6 +87,44 @@ struct OnCompletedEmpty { void operator()() const {} }; + +template +struct is_on_next_of +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)(*(CT*)nullptr)); + template + static not_void check(...); + + typedef decltype(check(0)) detail_result; + static const bool value = std::is_same::value; +}; + +template +struct is_on_error +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)(*(std::exception_ptr*)nullptr)); + template + static not_void check(...); + + static const bool value = std::is_same(0)), void>::value; +}; + +template +struct is_on_completed +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)()); + template + static not_void check(...); + + static const bool value = std::is_same(0)), void>::value; +}; + } template @@ -104,38 +142,224 @@ private: on_error_t onerror; on_completed_t oncompleted; + struct tag_this_type {}; + struct tag_function {}; + + template + struct resolve_tag + { + typedef typename std::conditional::type, dynamic_observer>::value, tag_this_type, + typename std::conditional::value, tag_subscription, tag_function>::type + >::type type; + }; + + template::type> + struct resolve_cs; + template + struct resolve_cs + { + auto operator()(const Arg& a) + -> decltype(a.cs) { + return a.cs; + } + auto operator()(Arg&& a) + -> decltype(a.cs) { + return std::move(a.cs); + } + }; + template + struct resolve_cs + { + Arg operator()(Arg a) { + return std::move(a); + } + }; + template + struct resolve_cs + { + composite_subscription operator()(const Arg& a) { + return composite_subscription(); + } + }; + + template::type> + struct resolve_onnext; + template + struct resolve_onnext + { + auto operator()(const Arg& a) + -> decltype(a.onnext) { + return a.onnext; + } + auto operator()(Arg&& a) + -> decltype(a.onnext) { + return std::move(a.onnext); + } + }; + template + struct resolve_onnext + { + template + on_next_t operator()(const Arg1& a1) { + return on_next_t(); + } + template + Arg2 operator()(const Arg1&, Arg2 a2) { + static_assert(detail::is_on_next_of::value || std::is_same::value, + "Function supplied for on_next must be a function with the signature void(T);"); + return std::move(a2); + } + }; + template + struct resolve_onnext + { + template + Arg1 operator()(Arg1 a1) { + static_assert(detail::is_on_next_of::value || std::is_same::value, + "Function supplied for on_next must be a function with the signature void(T);"); + return std::move(a1); + } + template + Arg operator()(Arg1 a1, const Arg2&) { + static_assert(detail::is_on_next_of::value || std::is_same::value, + "Function supplied for on_next must be a function with the signature void(T);"); + return std::move(a1); + } + }; + + template::type> + struct resolve_onerror; + template + struct resolve_onerror + { + auto operator()(const Arg& a) + -> decltype(a.onerror) { + return a.onerror; + } + auto operator()(Arg&& a) + -> decltype(a.onerror) { + return std::move(a.onerror); + } + }; + template + struct resolve_onerror + { + template + on_error_t operator()(const Arg1& a1) { + return on_error_t(); + } + template + Arg2 operator()(const Arg1&, Arg2 a2) { + static_assert(detail::is_on_error::value || std::is_same::value, + "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); + return std::move(a2); + } + }; + template + struct resolve_onerror + { + template + on_error_t operator()(const Arg1& a1) { + return on_error_t(); + } + template + Arg1 operator()(Arg1 a1, const Arg2&) { + static_assert(detail::is_on_error::value || std::is_same::value, + "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); + return std::move(a1); + } + }; + + template::type> + struct resolve_oncompleted; + template + struct resolve_oncompleted + { + auto operator()(const Arg& a) + -> decltype(a.oncompleted) { + return a.oncompleted; + } + auto operator()(Arg&& a) + -> decltype(a.oncompleted) { + return std::move(a.oncompleted); + } + }; + template + struct resolve_oncompleted + { + template + on_completed_t operator()(const Arg1& a1) { + return on_completed_t(); + } + template + Arg2 operator()(const Arg1&, Arg2 a2) { + static_assert(detail::is_on_completed::value || std::is_same::value, + "Function supplied for on_completed must be a function with the signature void();"); + return std::move(a2); + } + }; + template + struct resolve_oncompleted + { + template + on_completed_t operator()(const Arg1& a1) { + return on_completed_t(); + } + template + Arg1 operator()(Arg1 a1, const Arg2&) { + static_assert(detail::is_on_completed::value || std::is_same::value, + "Function supplied for on_completed must be a function with the signature void();"); + return std::move(a1); + } + }; + public: dynamic_observer() { } - dynamic_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : base_type(std::move(cs)) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) + + template + explicit dynamic_observer(Arg a) + : base_type(resolve_cs()(a)) + , onnext(resolve_onnext()(a)) + , onerror(resolve_onerror()(a)) + , oncompleted(resolve_oncompleted()(a)) { } - dynamic_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : base_type(composite_subscription()) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) + + template + dynamic_observer(Arg1 a1, Arg2 a2) + : base_type(resolve_cs()(a1)) + , onnext(resolve_onnext()(a1, a2)) + , onerror(resolve_onerror()(a2, on_error_t())) + , oncompleted(resolve_oncompleted()(on_completed_t(), on_completed_t())) { } - dynamic_observer(const dynamic_observer& o) - : base_type(o) - , onnext(o.onnext) - , onerror(o.onerror) - , oncompleted(o.oncompleted) + + template + dynamic_observer(Arg1 a1, Arg2 a2, Arg3 a3) + : base_type(resolve_cs()(a1)) + , onnext(resolve_onnext()(a1, a2)) + , onerror(resolve_onerror()(a2, a3)) + , oncompleted(resolve_oncompleted()(a3, on_completed_t())) { } - dynamic_observer(dynamic_observer&& o) - : base_type(std::move(o)) - , onnext(std::move(o.onnext)) - , onerror(std::move(o.onerror)) - , oncompleted(std::move(o.oncompleted)) + + template + dynamic_observer(composite_subscription cs, OnNext n, OnError e, OnCompleted c) + : base_type(std::move(cs)) + , onnext(std::move(n)) + , onerror(std::move(e)) + , oncompleted(std::move(c)) { + static_assert(detail::is_on_next_of::value || std::is_same::value, + "Function supplied for on_next must be a function with the signature void(T);"); + static_assert(detail::is_on_error::value || std::is_same::value, + "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); + static_assert(detail::is_on_completed::value || std::is_same::value, + "Function supplied for on_completed must be a function with the signature void();"); } + dynamic_observer& operator=(dynamic_observer o) { swap(o); return *this; @@ -165,7 +389,7 @@ public: } }; -template +template class static_observer : public observer_base { public: @@ -179,18 +403,19 @@ private: on_completed_t oncompleted; public: - static_observer() - { - } - static_observer(composite_subscription cs, on_next_t n = nullptr, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(std::move(cs)) + static_assert(detail::is_on_next_of::value, "Function supplied for on_next must be a function with the signature void(T);"); + static_assert(detail::is_on_error::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); + static_assert(detail::is_on_completed::value, "Function supplied for on_completed must be a function with the signature void();"); + + explicit static_observer(on_next_t n = on_next_t(), on_error_t e = on_error_t(), on_completed_t c = on_completed_t()) + : observer_base(composite_subscription()) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } - static_observer(on_next_t n, on_error_t e = nullptr, on_completed_t c = nullptr) - : observer_base(composite_subscription()) + explicit static_observer(composite_subscription cs, on_next_t n = on_next_t(), on_error_t e = on_error_t(), on_completed_t c = on_completed_t()) + : observer_base(std::move(cs)) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) @@ -274,17 +499,13 @@ public: if (is_subscribed()) { detacher protect(this); inner.on_error(e); - protect.that = nullptr; } - unsubscribe(); } void on_completed() const { if (is_subscribed()) { detacher protect(this); inner.on_completed(); - protect.that = nullptr; } - unsubscribe(); } typename this_type::subscription_type get_subscription() { return inner.get_subscription(); @@ -355,16 +576,16 @@ auto make_observer(I i, tag_observer&&) struct tag_function {}; template auto make_observer(OnNext n, tag_function&&) - -> observer> { - return observer>( - static_observer(std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); + -> observer> { + return observer>( + static_observer(std::move(n))); } template auto make_observer(OnNext n, OnError e, tag_function&&) - -> observer> { - return observer>( - static_observer(std::move(n), std::move(e), detail::OnCompletedEmpty())); + -> observer> { + return observer>( + static_observer(std::move(n), std::move(e))); } template @@ -376,16 +597,16 @@ auto make_observer(OnNext n, OnError e, OnCompleted c, tag_function&&) template auto make_observer(composite_subscription cs, OnNext n, tag_subscription&&) - -> observer> { - return observer>( - static_observer(std::move(cs), std::move(n), detail::OnErrorEmpty(), detail::OnCompletedEmpty())); + -> observer> { + return observer>( + static_observer(std::move(cs), std::move(n))); } template auto make_observer(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) - -> observer> { - return observer>( - static_observer(std::move(cs), std::move(n), std::move(e), detail::OnCompletedEmpty())); + -> observer> { + return observer>( + static_observer(std::move(cs), std::move(n), std::move(e))); } } @@ -421,14 +642,34 @@ auto make_observer(composite_subscription cs, OnNext n, OnError e, OnCompleted c static_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } -template -auto make_observer_dynamic(typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) +template +auto make_observer_dynamic(OnNext n) + -> observer { + return observer(dynamic_observer(std::move(n))); +} +template +auto make_observer_dynamic(OnNext n, OnError e) + -> observer { + return observer(dynamic_observer(std::move(n), std::move(e))); +} +template +auto make_observer_dynamic(OnNext n, OnError e, OnCompleted c) -> observer { return observer(dynamic_observer(std::move(n), std::move(e), std::move(c))); } -template -auto make_observer_dynamic(composite_subscription cs, typename dynamic_observer::on_next_t n, typename dynamic_observer::on_error_t e = nullptr, typename dynamic_observer::on_completed_t c = nullptr) +template +auto make_observer_dynamic(composite_subscription cs, OnNext n) + -> observer { + return observer(dynamic_observer(std::move(cs), std::move(n))); +} +template +auto make_observer_dynamic(composite_subscription cs, OnNext n, OnError e) + -> observer { + return observer(dynamic_observer(std::move(cs), std::move(n), std::move(e))); +} +template +auto make_observer_dynamic(composite_subscription cs, OnNext n, OnError e, OnCompleted c) -> observer { return observer(dynamic_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); } -- GitLab From 9ad402dfd9c1b4667ddf138d1a1c6f1594cc49d4 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 21 Feb 2014 00:58:46 -0800 Subject: [PATCH 209/782] Allow insertion of user operators --- Rx/CPP/src/rxcpp/rx-observable.hpp | 44 +++++++++++++++++++++++++++-- Rx/CPP/src/rxcpp/rx-test.hpp | 6 ++++ Rx/CPP/test/v2/operators/filter.cpp | 11 ++++++-- 3 files changed, 56 insertions(+), 5 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp index 7d201cf..5f0fec5 100644 --- a/Rx/CPP/src/rxcpp/rx-observable.hpp +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -9,6 +9,23 @@ namespace rxcpp { +namespace detail { + +template +struct is_operator_factory_for +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)(*(CS*)nullptr)); + template + static not_void check(...); + + typedef decltype(check(0)) detail_result; + static const bool value = !std::is_same::value; +}; + +} + template class dynamic_observable : public rxs::source_base @@ -82,6 +99,7 @@ observable make_dynamic_observable(Source&& s) { template class observable { + typedef observable this_type; mutable SourceOperator source_operator; private: @@ -176,6 +194,18 @@ public: observable(const observable& o) : source_operator(o.source_operator) {} + // implicit conversion between observables of the same value_type + template + observable(observable&& o) + : source_operator(std::move(o.source_operator)) + {} + + observable(const observable& o) + : source_operator(o.source_operator) + {} + observable(observable&& o) + : source_operator(std::move(o.source_operator)) + {} #if 0 template @@ -221,6 +251,14 @@ public: return observable>( rxo::detail::filter(*this, std::move(p))); } + + template + auto op(OperatorFactory&& of) const + -> decltype(of(*(this_type*)nullptr)) { + static_assert(detail::is_operator_factory_for::value, "Function passed for op() must have the signature Result(SourceObservable)"); + return of(*this); + } + }; // observable<> has static methods to construct observable sources and adaptors. @@ -241,9 +279,9 @@ public: } template -auto operator >> (rxcpp::observable source, OperatorFactory&& op) - -> decltype(op(source)){ - return op(source); +auto operator >> (const rxcpp::observable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } #endif diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/CPP/src/rxcpp/rx-test.hpp index 4280e1f..d4d6581 100644 --- a/Rx/CPP/src/rxcpp/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/rx-test.hpp @@ -111,6 +111,12 @@ namespace rxt=test; } +template +auto operator >> (const rxcpp::test::testable_observable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); +} + #include "schedulers/rx-test.hpp" #endif diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index a69df05..abe5604 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -140,7 +140,10 @@ SCENARIO("subject test", "[subject][subjects]"){ return 0; }); #endif - sub.get_observable().subscribe([c](int){++(*c);}); + sub.get_observable() + // demonstrates insertion of user definied operator + .op(rxo::filter([](int){return true;})) + .subscribe([c](int){++(*c);}); } auto o = sub.get_observer(); @@ -185,7 +188,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ WHEN("filtered to ints that are primes"){ auto res = sc->start( [&xs, &invoked]() { -#if RXCPP_USE_OBSERVABLE_MEMBERS +#if 0 && RXCPP_USE_OBSERVABLE_MEMBERS return xs .filter([&invoked](int x) { invoked++; @@ -199,6 +202,10 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ invoked++; return IsPrime(x); }) + // demonstrates insertion of user definied operator + >> [](rx::observable o)->rx::observable{ + return rxo::filter([](int){return true;})(o); + } // forget type to workaround lambda deduction bug on msvc 2013 >> rxo::as_dynamic(); #endif -- GitLab From 2aa62955ead93f877291d9b12db1ef6375c0054e Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 21 Feb 2014 09:17:48 -0800 Subject: [PATCH 210/782] add tests for subject --- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 32 +- Rx/CPP/test/v2/operators/filter.cpp | 130 ------- Rx/CPP/test/v2/subjects/subject.cpp | 430 +++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 4 files changed, 454 insertions(+), 139 deletions(-) create mode 100644 Rx/CPP/test/v2/subjects/subject.cpp diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index 7c1c67f..7c337a4 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -40,6 +40,7 @@ class multicast_observer : current(mode::Casting) { } + std::atomic has_observers; std::atomic completers; std::mutex lock; typename mode::type current; @@ -75,11 +76,13 @@ class multicast_observer default: abort(); } + state->has_observers.exchange(false); } } completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) : state(s) { + state->has_observers.exchange(true); ++state->completers; if (old) { observers.reserve(old->observers.size() + 1); @@ -125,6 +128,11 @@ public: , b(std::make_shared()) { } + + bool has_observers() const { + return b->state->has_observers; + } + void add(observer o) const { std::unique_lock guard(b->state->lock); switch (b->state->current) { @@ -155,16 +163,18 @@ public: } } void on_next(T t) const { - std::shared_ptr c; - { - std::unique_lock guard(b->state->lock); - if (!b->completer) { - return; + if (has_observers()) { + std::shared_ptr c; + { + std::unique_lock guard(b->state->lock); + if (!b->completer) { + return; + } + c = b->completer; + } + for (auto& o : c->observers) { + o.on_next(std::move(t)); } - c = b->completer; - } - for (auto& o : c->observers) { - o.on_next(std::move(t)); } } void on_error(std::exception_ptr e) const { @@ -205,6 +215,10 @@ public: { } + bool has_observers() const { + return s.has_observers(); + } + observer> get_observer() const { return observer>(s); } diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index abe5604..2c6e134 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -29,136 +29,6 @@ bool IsPrime(int x) } } -SCENARIO("subject test", "[subject][subjects]"){ - GIVEN("a subject"){ - WHEN("multicasting a million ints"){ - using namespace std::chrono; - typedef steady_clock clock; - - const int onnextcalls = 10000000; - - { - int c = 0; - int n = 1; - auto o = rx::make_observer([&c](int){++c;}); - auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { - o.on_next(i); - } - o.on_completed(); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "loop no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - } - - { - int c = 0; - int n = 1; - auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe([&c](int){++c;}); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "range no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - } - - { - std::mutex m; - int c = 0; - int n = 1; - auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { - std::unique_lock guard(m); - ++c; - } - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - } - - for (int n = 0; n < 10; n++) - { - auto c = std::make_shared(0); - rxsub::subject sub; - -#if RXCPP_SUBJECT_TEST_ASYNC - std::vector> f(n); -#endif - - for (int i = 0; i < n; i++) { -#if RXCPP_SUBJECT_TEST_ASYNC - f[i] = std::async([sub]() { - auto source = sub.get_observable(); - auto subscription = sub.get_observer(); - while(subscription.is_subscribed()) { - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - rx::composite_subscription cs; - source.subscribe(cs, [cs](int){ - cs.unsubscribe(); - }); - } - return 0; - }); -#endif - sub.get_observable().subscribe([c](int){++(*c);}); - } - - auto o = sub.get_observer(); - - auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { - o.on_next(i); - } - o.on_completed(); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "loop : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - } - - for (int n = 0; n < 10; n++) - { - auto c = std::make_shared(0); - rxsub::subject sub; - -#if RXCPP_SUBJECT_TEST_ASYNC - std::vector> f(n); -#endif - - for (int i = 0; i < n; i++) { -#if RXCPP_SUBJECT_TEST_ASYNC - f[i] = std::async([sub]() { - while(sub.get_observer().is_subscribed()) { - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - rx::composite_subscription cs; - sub.get_observable().subscribe(cs, [cs](int){ - cs.unsubscribe(); - }); - } - return 0; - }); -#endif - sub.get_observable() - // demonstrates insertion of user definied operator - .op(rxo::filter([](int){return true;})) - .subscribe([c](int){++(*c);}); - } - - auto o = sub.get_observer(); - - auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe(o); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "range : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - } - } - } -} - SCENARIO("filter stops on completion", "[filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); diff --git a/Rx/CPP/test/v2/subjects/subject.cpp b/Rx/CPP/test/v2/subjects/subject.cpp new file mode 100644 index 0000000..8be2df8 --- /dev/null +++ b/Rx/CPP/test/v2/subjects/subject.cpp @@ -0,0 +1,430 @@ + +#define RXCPP_USE_OBSERVABLE_MEMBERS 1 +#define RXCPP_SUBJECT_TEST_ASYNC 1 + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + + +SCENARIO("subject test", "[hide][subject][subjects][perf]"){ + GIVEN("a subject"){ + WHEN("multicasting a million ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + const int onnextcalls = 10000000; + + { + int c = 0; + int n = 1; + auto o = rx::make_observer([&c](int){++c;}); + auto start = clock::now(); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); + } + o.on_completed(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + { + int c = 0; + int n = 1; + auto start = clock::now(); + rxs::range(0, onnextcalls).subscribe([&c](int){++c;}); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "range no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + { + std::mutex m; + int c = 0; + int n = 1; + auto start = clock::now(); + for (int i = 0; i < onnextcalls; i++) { + std::unique_lock guard(m); + ++c; + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + for (int n = 0; n < 10; n++) + { + auto c = std::make_shared(0); + rxsub::subject sub; + +#if RXCPP_SUBJECT_TEST_ASYNC + std::vector> f(n); +#endif + + for (int i = 0; i < n; i++) { +#if RXCPP_SUBJECT_TEST_ASYNC + f[i] = std::async([sub]() { + auto source = sub.get_observable(); + auto subscription = sub.get_observer(); + while(subscription.is_subscribed()) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + rx::composite_subscription cs; + source.subscribe(cs, [cs](int){ + cs.unsubscribe(); + }); + } + return 0; + }); +#endif + sub.get_observable().subscribe([c](int){++(*c);}); + } + + auto o = sub.get_observer(); + + auto start = clock::now(); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); + } + o.on_completed(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + for (int n = 0; n < 10; n++) + { + auto c = std::make_shared(0); + rxsub::subject sub; + +#if RXCPP_SUBJECT_TEST_ASYNC + std::vector> f(n); +#endif + + for (int i = 0; i < n; i++) { +#if RXCPP_SUBJECT_TEST_ASYNC + f[i] = std::async([sub]() { + while(sub.get_observer().is_subscribed()) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + rx::composite_subscription cs; + sub.get_observable().subscribe(cs, [cs](int){ + cs.unsubscribe(); + }); + } + return 0; + }); +#endif + sub.get_observable() + // demonstrates insertion of user definied operator + .op(rxo::filter([](int){return true;})) + .subscribe([c](int){++(*c);}); + } + + auto o = sub.get_observer(); + + auto start = clock::now(); + rxs::range(0, onnextcalls).subscribe(o); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "range : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } + } +} + + + +SCENARIO("subject - infinite source", "[subject][subjects]"){ + GIVEN("a subject and an infinite source"){ + + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + m::recorded_type messages[] = { + m::on_next(70, 1), + m::on_next(110, 2), + m::on_next(220, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(410, 6), + m::on_next(520, 7), + m::on_next(630, 8), + m::on_next(710, 9), + m::on_next(870, 10), + m::on_next(940, 11), + m::on_next(1020, 12) + }; + auto xs = sc->make_hot_observable(messages); + + rxsub::subject s; + + auto results1 = sc->make_observer(); + + auto results2 = sc->make_observer(); + + auto results3 = sc->make_observer(); + + WHEN("multicasting an infinite source"){ + + + sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ + s = rxsub::subject(); return rxsc::make_action_empty();}); + sc->schedule_absolute(200, [&xs, &s](rxsc::action, rxsc::scheduler){ + xs.subscribe(s.get_observer()); return rxsc::make_action_empty();}); + sc->schedule_absolute(1000, [&s](rxsc::action, rxsc::scheduler){ + s.get_observer().unsubscribe(); return rxsc::make_action_empty();}); + + sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); + sc->schedule_absolute(400, [&s, &results2](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results2); return rxsc::make_action_empty();}); + sc->schedule_absolute(900, [&s, &results3](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results3); return rxsc::make_action_empty();}); + + sc->schedule_absolute(600, [&results1](rxsc::action, rxsc::scheduler){ + results1.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(700, [&results2](rxsc::action, rxsc::scheduler){ + results2.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(800, [&results1](rxsc::action, rxsc::scheduler){ + results1.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(950, [&results3](rxsc::action, rxsc::scheduler){ + results3.unsubscribe(); return rxsc::make_action_empty();}); + + sc->start(); + + THEN("result1 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(340, 5), + m::on_next(410, 6), + m::on_next(520, 7) + }; + auto required = rxu::to_vector(items); + auto actual = results1.messages(); + REQUIRE(required == actual); + } + + THEN("result2 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(410, 6), + m::on_next(520, 7), + m::on_next(630, 8) + }; + auto required = rxu::to_vector(items); + auto actual = results2.messages(); + REQUIRE(required == actual); + } + + THEN("result3 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(940, 11) + }; + auto required = rxu::to_vector(items); + auto actual = results3.messages(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("subject - finite source", "[subject][subjects]"){ + GIVEN("a subject and an finite source"){ + + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + m::recorded_type messages[] = { + m::on_next(70, 1), + m::on_next(110, 2), + m::on_next(220, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(410, 6), + m::on_next(520, 7), + m::on_completed(630), + m::on_next(640, 9), + m::on_completed(650), + m::on_error(660, std::exception("error on unsubscribed stream")) + }; + auto xs = sc->make_hot_observable(messages); + + rxsub::subject s; + + auto results1 = sc->make_observer(); + + auto results2 = sc->make_observer(); + + auto results3 = sc->make_observer(); + + WHEN("multicasting an infinite source"){ + + + sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ + s = rxsub::subject(); return rxsc::make_action_empty();}); + sc->schedule_absolute(200, [&xs, &s](rxsc::action, rxsc::scheduler){ + xs.subscribe(s.get_observer()); return rxsc::make_action_empty();}); + sc->schedule_absolute(1000, [&s](rxsc::action, rxsc::scheduler){ + s.get_observer().unsubscribe(); return rxsc::make_action_empty();}); + + sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); + sc->schedule_absolute(400, [&s, &results2](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results2); return rxsc::make_action_empty();}); + sc->schedule_absolute(900, [&s, &results3](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results3); return rxsc::make_action_empty();}); + + sc->schedule_absolute(600, [&results1](rxsc::action, rxsc::scheduler){ + results1.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(700, [&results2](rxsc::action, rxsc::scheduler){ + results2.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(800, [&results1](rxsc::action, rxsc::scheduler){ + results1.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(950, [&results3](rxsc::action, rxsc::scheduler){ + results3.unsubscribe(); return rxsc::make_action_empty();}); + + sc->start(); + + THEN("result1 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(340, 5), + m::on_next(410, 6), + m::on_next(520, 7) + }; + auto required = rxu::to_vector(items); + auto actual = results1.messages(); + REQUIRE(required == actual); + } + + THEN("result2 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(410, 6), + m::on_next(520, 7), + m::on_completed(630) + }; + auto required = rxu::to_vector(items); + auto actual = results2.messages(); + REQUIRE(required == actual); + } + + THEN("result3 contains expected messages"){ + m::recorded_type items[] = { + m::on_completed(900) + }; + auto required = rxu::to_vector(items); + auto actual = results3.messages(); + REQUIRE(required == actual); + } + + } + } +} + + +SCENARIO("subject - on_error in source", "[subject][subjects]"){ + GIVEN("a subject and a source with an error"){ + + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + std::exception ex("subject on_error in stream"); + + m::recorded_type messages[] = { + m::on_next(70, 1), + m::on_next(110, 2), + m::on_next(220, 3), + m::on_next(270, 4), + m::on_next(340, 5), + m::on_next(410, 6), + m::on_next(520, 7), + m::on_error(630, ex), + m::on_next(640, 9), + m::on_completed(650), + m::on_error(660, std::exception("error on unsubscribed stream")) + }; + auto xs = sc->make_hot_observable(messages); + + rxsub::subject s; + + auto results1 = sc->make_observer(); + + auto results2 = sc->make_observer(); + + auto results3 = sc->make_observer(); + + WHEN("multicasting an infinite source"){ + + + sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ + s = rxsub::subject(); return rxsc::make_action_empty();}); + sc->schedule_absolute(200, [&xs, &s](rxsc::action, rxsc::scheduler){ + xs.subscribe(s.get_observer()); return rxsc::make_action_empty();}); + sc->schedule_absolute(1000, [&s](rxsc::action, rxsc::scheduler){ + s.get_observer().unsubscribe(); return rxsc::make_action_empty();}); + + sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); + sc->schedule_absolute(400, [&s, &results2](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results2); return rxsc::make_action_empty();}); + sc->schedule_absolute(900, [&s, &results3](rxsc::action, rxsc::scheduler){ + s.get_observable().subscribe(results3); return rxsc::make_action_empty();}); + + sc->schedule_absolute(600, [&results1](rxsc::action, rxsc::scheduler){ + results1.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(700, [&results2](rxsc::action, rxsc::scheduler){ + results2.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(800, [&results1](rxsc::action, rxsc::scheduler){ + results1.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(950, [&results3](rxsc::action, rxsc::scheduler){ + results3.unsubscribe(); return rxsc::make_action_empty();}); + + sc->start(); + + THEN("result1 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(340, 5), + m::on_next(410, 6), + m::on_next(520, 7) + }; + auto required = rxu::to_vector(items); + auto actual = results1.messages(); + REQUIRE(required == actual); + } + + THEN("result2 contains expected messages"){ + m::recorded_type items[] = { + m::on_next(410, 6), + m::on_next(520, 7), + m::on_error(630, ex) + }; + auto required = rxu::to_vector(items); + auto actual = results2.messages(); + REQUIRE(required == actual); + } + + THEN("result3 contains expected messages"){ + m::recorded_type items[] = { + m::on_error(900, ex) + }; + auto required = rxu::to_vector(items); + auto actual = results3.messages(); + REQUIRE(required == actual); + } + + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 93404a2..337711b 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -37,6 +37,7 @@ set(TEST_SOURCES ${TEST_DIR}/v2/subscriptions/observer.cpp ${TEST_DIR}/v2/subscriptions/subscription.cpp ${TEST_DIR}/v2/operators/filter.cpp + ${TEST_DIR}/v2/subjects/subject.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) -- GitLab From f3ac87ef4af81ce1ee8e895d8b42d88a9c8e126b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 21 Feb 2014 11:07:31 -0800 Subject: [PATCH 211/782] fixes for clang --- Rx/CPP/src/rxcpp/rx-observable.hpp | 15 ++--- Rx/CPP/src/rxcpp/rx-observer.hpp | 22 ++++---- Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 70 +++++++----------------- Rx/CPP/test/v2/operators/filter.cpp | 10 ++-- Rx/CPP/test/v2/subjects/subject.cpp | 6 +- 5 files changed, 47 insertions(+), 76 deletions(-) diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp index 5f0fec5..2b83ae1 100644 --- a/Rx/CPP/src/rxcpp/rx-observable.hpp +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -39,6 +39,14 @@ class dynamic_observable }; std::shared_ptr state; + void construct(const dynamic_observable& o, rxs::tag_source&&) { + state = o.state; + } + + void construct(dynamic_observable&& o, rxs::tag_source&&) { + state = std::move(o.state); + } + template void construct(SO so, rxs::tag_source&&) { state->on_subscribe = [so](observer o) mutable { @@ -200,13 +208,6 @@ public: : source_operator(std::move(o.source_operator)) {} - observable(const observable& o) - : source_operator(o.source_operator) - {} - observable(observable&& o) - : source_operator(std::move(o.source_operator)) - {} - #if 0 template void on_subscribe(observer o) const { diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/CPP/src/rxcpp/rx-observer.hpp index 968901b..bdeccae 100644 --- a/Rx/CPP/src/rxcpp/rx-observer.hpp +++ b/Rx/CPP/src/rxcpp/rx-observer.hpp @@ -205,7 +205,7 @@ private: } template Arg2 operator()(const Arg1&, Arg2 a2) { - static_assert(detail::is_on_next_of::value || std::is_same::value, + static_assert(detail::is_on_next_of::value || std::is_same::value, "Function supplied for on_next must be a function with the signature void(T);"); return std::move(a2); } @@ -215,13 +215,13 @@ private: { template Arg1 operator()(Arg1 a1) { - static_assert(detail::is_on_next_of::value || std::is_same::value, + static_assert(detail::is_on_next_of::value || std::is_same::value, "Function supplied for on_next must be a function with the signature void(T);"); return std::move(a1); } template Arg operator()(Arg1 a1, const Arg2&) { - static_assert(detail::is_on_next_of::value || std::is_same::value, + static_assert(detail::is_on_next_of::value || std::is_same::value, "Function supplied for on_next must be a function with the signature void(T);"); return std::move(a1); } @@ -250,7 +250,7 @@ private: } template Arg2 operator()(const Arg1&, Arg2 a2) { - static_assert(detail::is_on_error::value || std::is_same::value, + static_assert(detail::is_on_error::value || std::is_same::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); return std::move(a2); } @@ -264,13 +264,13 @@ private: } template Arg1 operator()(Arg1 a1, const Arg2&) { - static_assert(detail::is_on_error::value || std::is_same::value, + static_assert(detail::is_on_error::value || std::is_same::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); return std::move(a1); } }; - template::type> + template::type> struct resolve_oncompleted; template struct resolve_oncompleted @@ -293,7 +293,7 @@ private: } template Arg2 operator()(const Arg1&, Arg2 a2) { - static_assert(detail::is_on_completed::value || std::is_same::value, + static_assert(detail::is_on_completed::value || std::is_same::value, "Function supplied for on_completed must be a function with the signature void();"); return std::move(a2); } @@ -307,7 +307,7 @@ private: } template Arg1 operator()(Arg1 a1, const Arg2&) { - static_assert(detail::is_on_completed::value || std::is_same::value, + static_assert(detail::is_on_completed::value || std::is_same::value, "Function supplied for on_completed must be a function with the signature void();"); return std::move(a1); } @@ -352,11 +352,11 @@ public: , onerror(std::move(e)) , oncompleted(std::move(c)) { - static_assert(detail::is_on_next_of::value || std::is_same::value, + static_assert(detail::is_on_next_of::value || std::is_same::value, "Function supplied for on_next must be a function with the signature void(T);"); - static_assert(detail::is_on_error::value || std::is_same::value, + static_assert(detail::is_on_error::value || std::is_same::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); - static_assert(detail::is_on_completed::value || std::is_same::value, + static_assert(detail::is_on_completed::value || std::is_same::value, "Function supplied for on_completed must be a function with the signature void();"); } diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index 7c337a4..4ee579d 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -40,7 +40,6 @@ class multicast_observer : current(mode::Casting) { } - std::atomic has_observers; std::atomic completers; std::mutex lock; typename mode::type current; @@ -52,37 +51,11 @@ class multicast_observer { ~completer_type() { - if (--state->completers == 0) { - std::unique_lock guard(state->lock); - switch(state->current) { - case mode::Casting: - break; - case mode::Errored: - { - guard.unlock(); - for (auto& o : observers) { - o.on_error(state->error); - } - } - break; - case mode::Completed: - { - guard.unlock(); - for (auto& o : observers) { - o.on_completed(); - } - } - break; - default: - abort(); - } - state->has_observers.exchange(false); - } + --state->completers; } completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) : state(s) { - state->has_observers.exchange(true); ++state->completers; if (old) { observers.reserve(old->observers.size() + 1); @@ -128,11 +101,6 @@ public: , b(std::make_shared()) { } - - bool has_observers() const { - return b->state->has_observers; - } - void add(observer o) const { std::unique_lock guard(b->state->lock); switch (b->state->current) { @@ -163,18 +131,16 @@ public: } } void on_next(T t) const { - if (has_observers()) { - std::shared_ptr c; - { - std::unique_lock guard(b->state->lock); - if (!b->completer) { - return; - } - c = b->completer; - } - for (auto& o : c->observers) { - o.on_next(std::move(t)); + std::shared_ptr c; + { + std::unique_lock guard(b->state->lock); + if (!b->completer) { + return; } + c = b->completer; + } + for (auto& o : c->observers) { + o.on_next(std::move(t)); } } void on_error(std::exception_ptr e) const { @@ -184,7 +150,11 @@ public: b->state->current = mode::Errored; auto c = std::move(b->completer); guard.unlock(); - // destruct completer outside the lock + if (c) { + for (auto& o : c->observers) { + o.on_error(e); + } + } } } void on_completed() const { @@ -193,7 +163,11 @@ public: b->state->current = mode::Completed; auto c = std::move(b->completer); guard.unlock(); - // destruct completer outside the lock + if (c) { + for (auto& o : c->observers) { + o.on_completed(); + } + } } } }; @@ -215,10 +189,6 @@ public: { } - bool has_observers() const { - return s.has_observers(); - } - observer> get_observer() const { return observer>(s); } diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index 2c6e134..fc40652 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -50,7 +50,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ m::on_next(580, 11), m::on_completed(600), m::on_next(610, 12), - m::on_error(620, std::exception()), + m::on_error(620, std::runtime_error("error in unsubscribed stream")), m::on_completed(630) }; auto xs = sc->make_hot_observable(messages); @@ -193,7 +193,7 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ long invoked = 0; - std::exception ex("filter on_error from source"); + std::runtime_error ex("filter on_error from source"); auto xs = sc->make_hot_observable( [ex]() { @@ -211,7 +211,7 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ m::on_next(580, 11), m::on_error(600, ex), m::on_next(610, 12), - m::on_error(620, std::exception()), + m::on_error(620, std::runtime_error("error in unsubscribed stream")), m::on_completed(630) }; return rxu::to_vector(messages); @@ -278,7 +278,7 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ long invoked = 0; - std::exception ex("filter predicate error"); + std::runtime_error ex("filter predicate error"); auto xs = sc->make_hot_observable( []() { @@ -296,7 +296,7 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ m::on_next(580, 11), m::on_completed(600), m::on_next(610, 12), - m::on_error(620, std::exception()), + m::on_error(620, std::runtime_error("error in unsubscribed stream")), m::on_completed(630) }; return rxu::to_vector(messages); diff --git a/Rx/CPP/test/v2/subjects/subject.cpp b/Rx/CPP/test/v2/subjects/subject.cpp index 8be2df8..c8b8fbd 100644 --- a/Rx/CPP/test/v2/subjects/subject.cpp +++ b/Rx/CPP/test/v2/subjects/subject.cpp @@ -259,7 +259,7 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ m::on_completed(630), m::on_next(640, 9), m::on_completed(650), - m::on_error(660, std::exception("error on unsubscribed stream")) + m::on_error(660, std::runtime_error("error on unsubscribed stream")) }; auto xs = sc->make_hot_observable(messages); @@ -341,7 +341,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ auto sc = std::make_shared(); typedef rxsc::test::messages m; - std::exception ex("subject on_error in stream"); + std::runtime_error ex("subject on_error in stream"); m::recorded_type messages[] = { m::on_next(70, 1), @@ -354,7 +354,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ m::on_error(630, ex), m::on_next(640, 9), m::on_completed(650), - m::on_error(660, std::exception("error on unsubscribed stream")) + m::on_error(660, std::runtime_error("error on unsubscribed stream")) }; auto xs = sc->make_hot_observable(messages); -- GitLab From 1b7277c2e382c36d6f3e02305766ec2602353999 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 21 Feb 2014 11:18:31 -0800 Subject: [PATCH 212/782] add back has_observers() how did this get lost? --- .gitattributes | 63 ++++++++++++++++++++++++ Rx/CPP/src/rxcpp/subjects/rx-subject.hpp | 33 +++++++++---- 2 files changed, 86 insertions(+), 10 deletions(-) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp index 4ee579d..fafdb14 100644 --- a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp @@ -40,6 +40,7 @@ class multicast_observer : current(mode::Casting) { } + std::atomic has_observers; std::atomic completers; std::mutex lock; typename mode::type current; @@ -51,11 +52,14 @@ class multicast_observer { ~completer_type() { - --state->completers; + if (--state->completers == 0) { + state->has_observers.exchange(false); + } } completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) : state(s) { + state->has_observers.exchange(true); ++state->completers; if (old) { observers.reserve(old->observers.size() + 1); @@ -101,6 +105,9 @@ public: , b(std::make_shared()) { } + bool has_observers() const { + return b->state->has_observers; + } void add(observer o) const { std::unique_lock guard(b->state->lock); switch (b->state->current) { @@ -131,16 +138,18 @@ public: } } void on_next(T t) const { - std::shared_ptr c; - { - std::unique_lock guard(b->state->lock); - if (!b->completer) { - return; + if (has_observers()) { + std::shared_ptr c; + { + std::unique_lock guard(b->state->lock); + if (!b->completer) { + return; + } + c = b->completer; + } + for (auto& o : c->observers) { + o.on_next(std::move(t)); } - c = b->completer; - } - for (auto& o : c->observers) { - o.on_next(std::move(t)); } } void on_error(std::exception_ptr e) const { @@ -189,6 +198,10 @@ public: { } + bool has_observers() const { + return s.has_observers(); + } + observer> get_observer() const { return observer>(s); } -- GitLab From db9379a228e1298cc6e1f81a225b9f576ed0f744 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Fri, 21 Feb 2014 13:16:02 -0800 Subject: [PATCH 213/782] add map operator --- Rx/CPP/src/rxcpp/operators/rx-filter.hpp | 1 - Rx/CPP/src/rxcpp/operators/rx-map.hpp | 90 ++++++++++++++++ Rx/CPP/src/rxcpp/rx-includes.hpp | 1 + Rx/CPP/src/rxcpp/rx-observable.hpp | 7 ++ Rx/CPP/src/rxcpp/rx-operators.hpp | 4 +- Rx/CPP/src/rxcpp/rx-util.hpp | 126 +++++++++++++++++++++++ Rx/CPP/test/v2/operators/filter.cpp | 1 - Rx/CPP/test/v2/operators/map.cpp | 77 ++++++++++++++ Rx/CPP/test/v2/subjects/subject.cpp | 1 - projects/CMake/CMakeLists.txt | 1 + 10 files changed, 305 insertions(+), 4 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/operators/rx-map.hpp create mode 100644 Rx/CPP/test/v2/operators/map.cpp diff --git a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp index ffdeca6..d0cf9d2 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp @@ -40,7 +40,6 @@ struct filter : public operator_base filtered = !this->test(t); } catch(...) { o.on_error(std::current_exception()); - o.unsubscribe(); } if (!filtered) { o.on_next(std::move(t)); diff --git a/Rx/CPP/src/rxcpp/operators/rx-map.hpp b/Rx/CPP/src/rxcpp/operators/rx-map.hpp new file mode 100644 index 0000000..0ff9d2c --- /dev/null +++ b/Rx/CPP/src/rxcpp/operators/rx-map.hpp @@ -0,0 +1,90 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_MAP_HPP) +#define RXCPP_OPERATORS_RX_MAP_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct map : public operator_base +{ + typedef map this_type; + Observable source; + Selector select; + + struct tag_not_valid {}; + template + static auto check(int) -> decltype((*(CP*)nullptr)(*(CF*)nullptr)); + template + static tag_not_valid check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "map Selector must be a function with the signature map::value_type(map::source_value_type)"); + + map(Observable o, Selector s) + : source(std::move(o)) + , select(std::move(s)) + { + } + template + void on_subscribe(observer o) { + o.add(source.subscribe( + o.get_subscription(), + // on_next + [this, o](typename this_type::source_value_type st) { + util::detail::maybe selected; + try { + selected.reset(this->select(st)); + } catch(...) { + o.on_error(std::current_exception()); + } + if (!selected.empty()) { + o.on_next(std::move(*selected)); + } + }, + // on_error + [o](std::exception_ptr e) { + o.on_error(e); + }, + // on_completed + [o]() { + o.on_completed(); + } + )); + } +}; + +template +class map_factory +{ + Selector selector; +public: + map_factory(Selector p) : selector(std::move(p)) {} + template + auto operator()(Observable source) + -> observable::value_type, map> { + return observable::value_type, map>( + map(source, std::move(selector))); + } +}; + +} + +template +auto map(Selector p) + -> detail::map_factory { + return detail::map_factory(std::move(p)); +} + +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index 7b53b15..7e13fcc 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -42,6 +42,7 @@ #endif #if _MSC_VER >= 1800 +#pragma warning(disable: 4348) // false positives on : redefinition of default parameter : parameter 2 #define RXCPP_USE_VARIADIC_TEMPLATES 1 #endif diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp index 2b83ae1..f934023 100644 --- a/Rx/CPP/src/rxcpp/rx-observable.hpp +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -253,6 +253,13 @@ public: rxo::detail::filter(*this, std::move(p))); } + template + auto map(Selector s) const + -> observable::value_type, rxo::detail::map> { + return observable::value_type, rxo::detail::map>( + rxo::detail::map(*this, std::move(s))); + } + template auto op(OperatorFactory&& of) const -> decltype(of(*(this_type*)nullptr)) { diff --git a/Rx/CPP/src/rxcpp/rx-operators.hpp b/Rx/CPP/src/rxcpp/rx-operators.hpp index 497cb6f..535913d 100644 --- a/Rx/CPP/src/rxcpp/rx-operators.hpp +++ b/Rx/CPP/src/rxcpp/rx-operators.hpp @@ -12,10 +12,11 @@ namespace rxcpp { namespace operators { struct tag_operator {}; -template +template struct operator_base { typedef T value_type; + typedef From source_value_type; typedef tag_operator operator_tag; }; template @@ -36,5 +37,6 @@ namespace rxo=operators; #include "operators/rx-subscribe.hpp" #include "operators/rx-filter.hpp" +#include "operators/rx-map.hpp" #endif diff --git a/Rx/CPP/src/rxcpp/rx-util.hpp b/Rx/CPP/src/rxcpp/rx-util.hpp index 64a91ae..bb6e680 100644 --- a/Rx/CPP/src/rxcpp/rx-util.hpp +++ b/Rx/CPP/src/rxcpp/rx-util.hpp @@ -39,6 +39,132 @@ std::vector to_vector(const T (&arr) [size]) { namespace detail { +template +class maybe +{ + bool is_set; + typename std::aligned_storage::value>::type + storage; +public: + maybe() + : is_set(false) + { + } + + maybe(T value) + : is_set(false) + { + new (reinterpret_cast(&storage)) T(value); + is_set = true; + } + + maybe(const maybe& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(*other.get()); + is_set = true; + } + } + maybe(maybe&& other) + : is_set(false) + { + if (other.is_set) { + new (reinterpret_cast(&storage)) T(std::move(*other.get())); + is_set = true; + other.reset(); + } + } + + ~maybe() + { + reset(); + } + + typedef T value_type; + typedef T* iterator; + typedef const T* const_iterator; + + bool empty() const { + return !is_set; + } + + size_t size() const { + return is_set ? 1 : 0; + } + + iterator begin() { + return reinterpret_cast(&storage); + } + const_iterator begin() const { + return reinterpret_cast(&storage); + } + + iterator end() { + return reinterpret_cast(&storage) + size(); + } + const_iterator end() const { + return reinterpret_cast(&storage) + size(); + } + + T* operator->() { + if (!is_set) abort(); + return reinterpret_cast(&storage); + } + const T* operator->() const { + if (!is_set) abort(); + return reinterpret_cast(&storage); + } + + T& operator*() { + if (!is_set) abort(); + return *reinterpret_cast(&storage); + } + const T& operator*() const { + if (!is_set) abort(); + return *reinterpret_cast(&storage); + } + + T& value() { + if (!is_set) abort(); + return *reinterpret_cast(&storage); + } + const T& value() const { + if (!is_set) abort(); + return *reinterpret_cast(&storage); + } + + void reset() + { + if (is_set) { + is_set = false; + reinterpret_cast(&storage)->~T(); + } + } + + void reset(T value) { + if (is_set) { + *reinterpret_cast(&storage) = std::move(value); + } else { + new (reinterpret_cast(&storage)) T(std::move(value)); + is_set = true; + } + } + + maybe& operator=(const T& other) { + set(other); + return *this; + } + maybe& operator=(const maybe& other) { + if (const T* pother = other.get()) { + set(*pother); + } else { + reset(); + } + return *this; + } +}; + template class unwinder { diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/CPP/test/v2/operators/filter.cpp index fc40652..2e202be 100644 --- a/Rx/CPP/test/v2/operators/filter.cpp +++ b/Rx/CPP/test/v2/operators/filter.cpp @@ -1,6 +1,5 @@ #define RXCPP_USE_OBSERVABLE_MEMBERS 1 -#define RXCPP_SUBJECT_TEST_ASYNC 1 #include "rxcpp/rx.hpp" namespace rx=rxcpp; diff --git a/Rx/CPP/test/v2/operators/map.cpp b/Rx/CPP/test/v2/operators/map.cpp new file mode 100644 index 0000000..397287c --- /dev/null +++ b/Rx/CPP/test/v2/operators/map.cpp @@ -0,0 +1,77 @@ + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("map stops on completion", "[map][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + + long invoked = 0; + + m::recorded_type messages[] = { + m::on_next(180, 1), + m::on_next(210, 2), + m::on_next(240, 3), + m::on_next(290, 4), + m::on_next(350, 5), + m::on_completed(400), + m::on_next(410, -1), + m::on_completed(420), + m::on_error(430, std::runtime_error("error on unsubscribed stream")) + }; + auto xs = sc->make_hot_observable(messages); + + WHEN("mapped to ints that are one larger"){ + + auto res = sc->start( + [xs, &invoked]() { + return xs + .map([&invoked](int x) { + invoked++; + return x + 1; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + m::recorded_type items[] = { + m::on_next(210, 3), + m::on_next(240, 4), + m::on_next(290, 5), + m::on_next(350, 6), + m::on_completed(400) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + rxn::subscription items[] = { + m::subscribe(200, 400) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("map was called until completed"){ + REQUIRE(4 == invoked); + } + } + } +} diff --git a/Rx/CPP/test/v2/subjects/subject.cpp b/Rx/CPP/test/v2/subjects/subject.cpp index c8b8fbd..f1905a2 100644 --- a/Rx/CPP/test/v2/subjects/subject.cpp +++ b/Rx/CPP/test/v2/subjects/subject.cpp @@ -1,5 +1,4 @@ -#define RXCPP_USE_OBSERVABLE_MEMBERS 1 #define RXCPP_SUBJECT_TEST_ASYNC 1 #include "rxcpp/rx.hpp" diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 337711b..593fa6c 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -37,6 +37,7 @@ set(TEST_SOURCES ${TEST_DIR}/v2/subscriptions/observer.cpp ${TEST_DIR}/v2/subscriptions/subscription.cpp ${TEST_DIR}/v2/operators/filter.cpp + ${TEST_DIR}/v2/operators/map.cpp ${TEST_DIR}/v2/subjects/subject.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) -- GitLab From 538a758e1a2aa234cba949a8e200ab1e42ffa9d0 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 25 Feb 2014 17:10:42 -0800 Subject: [PATCH 214/782] add flat_map --- Rx/CPP/src/rxcpp/operators/rx-filter.hpp | 5 +- Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp | 209 +++++++++++++++++++++ Rx/CPP/src/rxcpp/operators/rx-map.hpp | 65 +++++-- Rx/CPP/src/rxcpp/rx-observable.hpp | 10 + Rx/CPP/src/rxcpp/rx-operators.hpp | 4 +- Rx/CPP/src/rxcpp/rx-predef.hpp | 17 ++ Rx/CPP/src/rxcpp/rx-test.hpp | 4 + Rx/CPP/test/v2/operators/flat_map.cpp | 99 ++++++++++ projects/CMake/CMakeLists.txt | 1 + 9 files changed, 391 insertions(+), 23 deletions(-) create mode 100644 Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp create mode 100644 Rx/CPP/test/v2/operators/flat_map.cpp diff --git a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp index d0cf9d2..ee61646 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-filter.hpp @@ -31,7 +31,7 @@ struct filter : public operator_base } template void on_subscribe(observer o) { - o.add(source.subscribe( + source.subscribe( o.get_subscription(), // on_next [this, o](T t) { @@ -40,6 +40,7 @@ struct filter : public operator_base filtered = !this->test(t); } catch(...) { o.on_error(std::current_exception()); + return; } if (!filtered) { o.on_next(std::move(t)); @@ -53,7 +54,7 @@ struct filter : public operator_base [o]() { o.on_completed(); } - )); + ); } }; diff --git a/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp b/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp new file mode 100644 index 0000000..e1f0b03 --- /dev/null +++ b/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp @@ -0,0 +1,209 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_FLATMAP_HPP) +#define RXCPP_OPERATORS_RX_FLATMAP_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct flat_map_traits { + typedef typename Observable::value_type source_value_type; + + struct tag_not_valid {}; + template + static auto collection_check(int) -> decltype((*(CCS*)nullptr)(*(CV*)nullptr)); + template + static tag_not_valid collection_check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "flat_map CollectionSelector must be a function with the signature observable(flat_map::source_value_type)"); + + typedef decltype((*(CollectionSelector*)nullptr)((*(source_value_type*)nullptr))) collection_type; + + static_assert(is_observable::value, "flat_map CollectionSelector must return an observable"); + + typedef typename collection_type::value_type collection_value_type; + + template + static auto result_check(int) -> decltype((*(CRS*)nullptr)(*(CV*)nullptr, *(CCV*)nullptr)); + template + static tag_not_valid result_check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "flat_map ResultSelector must be a function with the signature flat_map::value_type(flat_map::source_value_type, flat_map::collection_value_type)"); + + typedef decltype((*(ResultSelector*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; +}; + +template +struct flat_map + : public operator_base::value_type> +{ + typedef flat_map this_type; + typedef typename flat_map_traits traits; + + struct values + { + values(Observable o, CollectionSelector s, ResultSelector rs) + : source(std::move(o)) + , selectCollection(std::move(s)) + , selectResult(std::move(rs)) + { + } + Observable source; + CollectionSelector selectCollection; + ResultSelector selectResult; + }; + values initial; + + typedef typename traits::source_value_type source_value_type; + typedef typename traits::collection_type collection_type; + typedef typename traits::collection_value_type collection_value_type; + + flat_map(Observable o, CollectionSelector s, ResultSelector rs) + : initial(std::move(o), std::move(s), std::move(rs)) + { + } + + template + void on_subscribe(observer o) { + + typedef observer output_type; + struct state_type + : public values + { + state_type(values i, output_type oarg) + : values(std::move(i)) + , out(std::move(oarg)) + { + } + // on_completed on the output must wait until all the + // subscriptions have received on_completed + std::atomic subscriptions; + // because multiple sources are subscribed to by flat_map, + // calls to the output must be serialized by lock. + std::mutex lock; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::make_shared(initial, std::move(o)); + + composite_subscription cs; + cs.add(make_subscription([state](){ + if (--state->subscriptions == 0) { + std::unique_lock guard(state->lock); + state->out.on_completed(); + } + })); + + ++state->subscriptions; + + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + state->source.subscribe( + cs, + // on_next + [state](source_value_type st) { + util::detail::maybe selectedCollection; + try { + selectedCollection.reset(state->selectCollection(st)); + } catch(...) { + std::unique_lock guard(state->lock); + state->out.on_error(std::current_exception()); + return; + } + + composite_subscription cs; + + ++state->subscriptions; + + cs.add(make_subscription([state](){ + if (--state->subscriptions == 0) { + std::unique_lock guard(state->lock); + state->out.on_completed(); + } + })); + + // this subscribe does not share the source subscription + // so that when it is unsubscribed the source will continue + selectedCollection->subscribe( + cs, + // on_next + [state, st](collection_value_type ct) { + util::detail::maybe selectedResult; + try { + selectedResult.reset(state->selectResult(st, std::move(ct))); + } catch(...) { + std::unique_lock guard(state->lock); + state->out.on_error(std::current_exception()); + return; + } + std::unique_lock guard(state->lock); + state->out.on_next(std::move(*selectedResult)); + }, + // on_error + [state](std::exception_ptr e) { + // no need to track state->subscriptions + // after an error - complete will not be called. + std::unique_lock guard(state->lock); + state->out.on_error(e); + }, + //on_completed + [](){ + } + ); + }, + // on_error + [state](std::exception_ptr e) { + // no need to track state->subscriptions + // after an error - complete will not be called. + std::unique_lock guard(state->lock); + state->out.on_error(e); + }, + // on_completed + []() { + } + ); + } +}; + +template +class flat_map_factory +{ + CollectionSelector selectorCollection; + ResultSelector selectorResult; +public: + flat_map_factory(CollectionSelector s, ResultSelector rs) + : selectorCollection(std::move(rs)) + , selectorResult(std::move(s)) + { + } + + template + auto operator()(Observable source) + -> observable::value_type, flat_map> { + return observable::value_type, flat_map>( + flat_map(source, std::move(selectorCollection), std::move(selectorResult))); + } +}; + +} + +template +auto flat_map(CollectionSelector s, ResultSelector rs) + -> detail::flat_map_factory { + return detail::flat_map_factory(std::move(s), std::move(rs)); +} + +} + +} + +#endif diff --git a/Rx/CPP/src/rxcpp/operators/rx-map.hpp b/Rx/CPP/src/rxcpp/operators/rx-map.hpp index 0ff9d2c..b8f2207 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-map.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-map.hpp @@ -14,11 +14,24 @@ namespace operators { namespace detail { template -struct map : public operator_base +struct map + : public operator_base { typedef map this_type; - Observable source; - Selector select; + + struct values + { + values(Observable o, Selector s) + : source(std::move(o)) + , select(std::move(s)) + { + } + Observable source; + Selector select; + }; + values initial; + + typedef typename Observable::value_type source_value_type; struct tag_not_valid {}; template @@ -26,38 +39,52 @@ struct map : public operator_base static tag_not_valid check(...); - static_assert(!std::is_same(0)), tag_not_valid>::value, "map Selector must be a function with the signature map::value_type(map::source_value_type)"); + static_assert(!std::is_same(0)), tag_not_valid>::value, "map Selector must be a function with the signature map::value_type(map::source_value_type)"); map(Observable o, Selector s) - : source(std::move(o)) - , select(std::move(s)) + : initial(std::move(o), std::move(s)) { } + template void on_subscribe(observer o) { - o.add(source.subscribe( - o.get_subscription(), + + typedef observer output_type; + struct state_type + : public values + { + state_type(values i, output_type oarg) + : values(std::move(i)) + , out(std::move(oarg)) + { + } + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::make_shared(initial, std::move(o)); + + state->source.subscribe( + state->out.get_subscription(), // on_next - [this, o](typename this_type::source_value_type st) { + [state](typename this_type::source_value_type st) { util::detail::maybe selected; try { - selected.reset(this->select(st)); + selected.reset(state->select(st)); } catch(...) { - o.on_error(std::current_exception()); - } - if (!selected.empty()) { - o.on_next(std::move(*selected)); + state->out.on_error(std::current_exception()); + return; } + state->out.on_next(std::move(*selected)); }, // on_error - [o](std::exception_ptr e) { - o.on_error(e); + [state](std::exception_ptr e) { + state->out.on_error(e); }, // on_completed - [o]() { - o.on_completed(); + [state]() { + state->out.on_completed(); } - )); + ); } }; diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/CPP/src/rxcpp/rx-observable.hpp index f934023..cf1bc87 100644 --- a/Rx/CPP/src/rxcpp/rx-observable.hpp +++ b/Rx/CPP/src/rxcpp/rx-observable.hpp @@ -106,10 +106,13 @@ observable make_dynamic_observable(Source&& s) { template class observable + : public observable_base { typedef observable this_type; mutable SourceOperator source_operator; + static_assert(std::is_same::value, "SourceOperator::value_type must be the same as T in observable"); + private: template friend class observable; @@ -260,6 +263,13 @@ public: rxo::detail::map(*this, std::move(s))); } + template + auto flat_map(CollectionSelector s, ResultSelector rs) const + -> observable::value_type, rxo::detail::flat_map> { + return observable::value_type, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::move(s), std::move(rs))); + } + template auto op(OperatorFactory&& of) const -> decltype(of(*(this_type*)nullptr)) { diff --git a/Rx/CPP/src/rxcpp/rx-operators.hpp b/Rx/CPP/src/rxcpp/rx-operators.hpp index 535913d..aa48e8c 100644 --- a/Rx/CPP/src/rxcpp/rx-operators.hpp +++ b/Rx/CPP/src/rxcpp/rx-operators.hpp @@ -12,11 +12,10 @@ namespace rxcpp { namespace operators { struct tag_operator {}; -template +template struct operator_base { typedef T value_type; - typedef From source_value_type; typedef tag_operator operator_tag; }; template @@ -38,5 +37,6 @@ namespace rxo=operators; #include "operators/rx-subscribe.hpp" #include "operators/rx-filter.hpp" #include "operators/rx-map.hpp" +#include "operators/rx-flat_map.hpp" #endif diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/CPP/src/rxcpp/rx-predef.hpp index 588f2d2..be88f04 100644 --- a/Rx/CPP/src/rxcpp/rx-predef.hpp +++ b/Rx/CPP/src/rxcpp/rx-predef.hpp @@ -27,6 +27,23 @@ class observable; template observable make_dynamic_observable(Source&&); +struct tag_observable {}; +template +struct observable_base { + typedef tag_observable observable_tag; + typedef T value_type; +}; +template +class is_observable +{ + template + static typename C::observable_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_observable>::value; +}; + } #endif diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/CPP/src/rxcpp/rx-test.hpp index d4d6581..a9db66d 100644 --- a/Rx/CPP/src/rxcpp/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/rx-test.hpp @@ -80,6 +80,8 @@ public: } }; +struct tag_test_observable : public tag_observable {}; + template class testable_observable : public observable> @@ -88,6 +90,8 @@ class testable_observable typedef typename detail::test_subject_base::type test_subject; test_subject ts; + typedef tag_test_observable observable_tag; + public: typedef typename detail::test_subject_base::recorded_type recorded_type; diff --git a/Rx/CPP/test/v2/operators/flat_map.cpp b/Rx/CPP/test/v2/operators/flat_map.cpp new file mode 100644 index 0000000..5cda90f --- /dev/null +++ b/Rx/CPP/test/v2/operators/flat_map.cpp @@ -0,0 +1,99 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("flat_map completes", "[flat_map][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages ms; + + long invoked = 0; + + m::recorded_type int_messages[] = { + m::on_next(100, 4), + m::on_next(200, 2), + m::on_next(300, 3), + m::on_next(400, 1), + m::on_completed(500) + }; + auto xs = sc->make_cold_observable(int_messages); + + ms::recorded_type string_messages[] = { + ms::on_next(50, "foo"), + ms::on_next(100, "bar"), + ms::on_next(150, "baz"), + ms::on_next(200, "qux"), + ms::on_completed(250) + }; + auto ys = sc->make_cold_observable(string_messages); + + WHEN("each int is mapped to the strings"){ + + auto res = sc->start( + [&]() { + return xs + .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains strings repeated for each int"){ + ms::recorded_type items[] = { + ms::on_next(350, "foo"), + ms::on_next(400, "bar"), + ms::on_next(450, "baz"), + ms::on_next(450, "foo"), + ms::on_next(500, "qux"), + ms::on_next(500, "bar"), + ms::on_next(550, "baz"), + ms::on_next(550, "foo"), + ms::on_next(600, "qux"), + ms::on_next(600, "bar"), + ms::on_next(650, "baz"), + ms::on_next(650, "foo"), + ms::on_next(700, "bar"), + ms::on_next(700, "qux"), + ms::on_next(750, "baz"), + ms::on_next(800, "qux"), + ms::on_completed(850) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + rxn::subscription items[] = { + m::subscribe(200, 700) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + rxn::subscription items[] = { + ms::subscribe(300, 550), + ms::subscribe(400, 650), + ms::subscribe(500, 750), + ms::subscribe(600, 850) + }; + auto required = rxu::to_vector(items); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 593fa6c..3c43324 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -34,6 +34,7 @@ add_executable(rxcpp_test ${TEST_SOURCES}) # define the sources of the self test set(TEST_SOURCES ${TEST_DIR}/test.cpp + ${TEST_DIR}/v2/operators/flat_map.cpp ${TEST_DIR}/v2/subscriptions/observer.cpp ${TEST_DIR}/v2/subscriptions/subscription.cpp ${TEST_DIR}/v2/operators/filter.cpp -- GitLab From abd81841b216ea0a20b5cffd02cf3a02267f2798 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 25 Feb 2014 20:21:06 -0800 Subject: [PATCH 215/782] add tests and fix bugs --- Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp | 33 ++-- Rx/CPP/src/rxcpp/rx-includes.hpp | 2 +- Rx/CPP/src/rxcpp/rx-subscription.hpp | 2 +- Rx/CPP/test/v2/operators/flat_map.cpp | 174 +++++++++++++++++++++ 4 files changed, 198 insertions(+), 13 deletions(-) diff --git a/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp b/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp index e1f0b03..b53c5fc 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp @@ -88,22 +88,29 @@ struct flat_map std::atomic subscriptions; // because multiple sources are subscribed to by flat_map, // calls to the output must be serialized by lock. - std::mutex lock; + // the on_error/on_complete and unsubscribe calls can + // cause lock recursion. + std::recursive_mutex lock; output_type out; }; // take a copy of the values for each subscription auto state = std::make_shared(initial, std::move(o)); + ++state->subscriptions; + composite_subscription cs; + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.get_subscription().add(cs); + cs.add(make_subscription([state](){ if (--state->subscriptions == 0) { - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_completed(); } })); - ++state->subscriptions; - // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished @@ -115,18 +122,22 @@ struct flat_map try { selectedCollection.reset(state->selectCollection(st)); } catch(...) { - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_error(std::current_exception()); return; } + ++state->subscriptions; + composite_subscription cs; - ++state->subscriptions; + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.get_subscription().add(cs); cs.add(make_subscription([state](){ if (--state->subscriptions == 0) { - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_completed(); } })); @@ -141,18 +152,18 @@ struct flat_map try { selectedResult.reset(state->selectResult(st, std::move(ct))); } catch(...) { - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_error(std::current_exception()); return; } - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_next(std::move(*selectedResult)); }, // on_error [state](std::exception_ptr e) { // no need to track state->subscriptions // after an error - complete will not be called. - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_error(e); }, //on_completed @@ -164,7 +175,7 @@ struct flat_map [state](std::exception_ptr e) { // no need to track state->subscriptions // after an error - complete will not be called. - std::unique_lock guard(state->lock); + std::unique_lock guard(state->lock); state->out.on_error(e); }, // on_completed diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/CPP/src/rxcpp/rx-includes.hpp index 7e13fcc..347e443 100644 --- a/Rx/CPP/src/rxcpp/rx-includes.hpp +++ b/Rx/CPP/src/rxcpp/rx-includes.hpp @@ -38,11 +38,11 @@ #if defined(_MSC_VER) #if _MSC_VER > 1600 +#pragma warning(disable: 4348) // false positives on : redefinition of default parameter : parameter 2 #define RXCPP_USE_RVALUEREF 1 #endif #if _MSC_VER >= 1800 -#pragma warning(disable: 4348) // false positives on : redefinition of default parameter : parameter 2 #define RXCPP_USE_VARIADIC_TEMPLATES 1 #endif diff --git a/Rx/CPP/src/rxcpp/rx-subscription.hpp b/Rx/CPP/src/rxcpp/rx-subscription.hpp index 235d5e5..f1d2329 100644 --- a/Rx/CPP/src/rxcpp/rx-subscription.hpp +++ b/Rx/CPP/src/rxcpp/rx-subscription.hpp @@ -168,7 +168,7 @@ private: auto it = std::find(std::begin(subscriptions), end, s); if (it == end) { - subscriptions.emplace_back(std::move(s)); + subscriptions.emplace_back(s); } } return s; diff --git a/Rx/CPP/test/v2/operators/flat_map.cpp b/Rx/CPP/test/v2/operators/flat_map.cpp index 5cda90f..9e4c108 100644 --- a/Rx/CPP/test/v2/operators/flat_map.cpp +++ b/Rx/CPP/test/v2/operators/flat_map.cpp @@ -97,3 +97,177 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ } } } + + +SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages ms; + + long invoked = 0; + + m::recorded_type int_messages[] = { + m::on_next(100, 4), + m::on_next(200, 2), + m::on_next(300, 3), + m::on_next(400, 1), + m::on_next(500, 5), + m::on_next(700, 0) + }; + auto xs = sc->make_cold_observable(int_messages); + + ms::recorded_type string_messages[] = { + ms::on_next(50, "foo"), + ms::on_next(100, "bar"), + ms::on_next(150, "baz"), + ms::on_next(200, "qux"), + ms::on_completed(250) + }; + auto ys = sc->make_cold_observable(string_messages); + + WHEN("each int is mapped to the strings"){ + + auto res = sc->start( + [&]() { + return xs + .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains strings repeated for each int"){ + ms::recorded_type items[] = { + ms::on_next(350, "foo"), + ms::on_next(400, "bar"), + ms::on_next(450, "baz"), + ms::on_next(450, "foo"), + ms::on_next(500, "bar"), + ms::on_next(500, "qux"), + ms::on_next(550, "baz"), + ms::on_next(550, "foo"), + ms::on_next(600, "bar"), + ms::on_next(600, "qux"), + ms::on_next(650, "baz"), + ms::on_next(650, "foo"), + ms::on_next(700, "bar"), + ms::on_next(700, "qux"), + ms::on_next(750, "baz"), + ms::on_next(750, "foo"), + ms::on_next(800, "bar"), + ms::on_next(800, "qux"), + ms::on_next(850, "baz"), + ms::on_next(900, "qux"), + ms::on_next(950, "foo") + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + rxn::subscription items[] = { + m::subscribe(200, 1000) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + rxn::subscription items[] = { + ms::subscribe(300, 550), + ms::subscribe(400, 650), + ms::subscribe(500, 750), + ms::subscribe(600, 850), + ms::subscribe(700, 950), + ms::subscribe(900, 1000) + }; + auto required = rxu::to_vector(items); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto sc = std::make_shared(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages ms; + + long invoked = 0; + + m::recorded_type int_messages[] = { + m::on_next(100, 4), + m::on_next(200, 2), + m::on_next(300, 3), + m::on_next(400, 1), + m::on_completed(500) + }; + auto xs = sc->make_cold_observable(int_messages); + + std::runtime_error ex("filter on_error from inner source"); + + ms::recorded_type string_messages[] = { + ms::on_next(55, "foo"), + ms::on_next(104, "bar"), + ms::on_next(153, "baz"), + ms::on_next(202, "qux"), + ms::on_error(301, ex) + }; + auto ys = sc->make_cold_observable(string_messages); + + WHEN("each int is mapped to the strings"){ + + auto res = sc->start( + [&]() { + return xs + .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains strings repeated for each int"){ + ms::recorded_type items[] = { + ms::on_next(355, "foo"), + ms::on_next(404, "bar"), + ms::on_next(453, "baz"), + ms::on_next(455, "foo"), + ms::on_next(502, "qux"), + ms::on_next(504, "bar"), + ms::on_next(553, "baz"), + ms::on_next(555, "foo"), + ms::on_error(601, ex) + }; + auto required = rxu::to_vector(items); + auto actual = res.messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + rxn::subscription items[] = { + m::subscribe(200, 601) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + rxn::subscription items[] = { + ms::subscribe(300, 601), + ms::subscribe(400, 601), + ms::subscribe(500, 601), + ms::subscribe(600, 601) + }; + auto required = rxu::to_vector(items); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From 90d3ac9aea3025fc60869289aa261d1c9dfcf307 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 25 Feb 2014 22:48:14 -0800 Subject: [PATCH 216/782] clang fixes flat_map still has 2 failing tests.. ugh --- Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp | 57 ++++++++++------------ Rx/CPP/src/rxcpp/operators/rx-map.hpp | 5 +- Rx/CPP/src/rxcpp/rx-predef.hpp | 2 +- Rx/CPP/src/rxcpp/rx-subscription.hpp | 20 ++++---- Rx/CPP/src/rxcpp/rx-test.hpp | 4 +- 5 files changed, 42 insertions(+), 46 deletions(-) diff --git a/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp b/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp index b53c5fc..7ff88e1 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp @@ -46,7 +46,7 @@ struct flat_map : public operator_base::value_type> { typedef flat_map this_type; - typedef typename flat_map_traits traits; + typedef flat_map_traits traits; struct values { @@ -76,7 +76,8 @@ struct flat_map typedef observer output_type; struct state_type - : public values + : public std::enable_shared_from_this + , public values { state_type(values i, output_type oarg) : values(std::move(i)) @@ -85,7 +86,7 @@ struct flat_map } // on_completed on the output must wait until all the // subscriptions have received on_completed - std::atomic subscriptions; + std::atomic pendingCompletions; // because multiple sources are subscribed to by flat_map, // calls to the output must be serialized by lock. // the on_error/on_complete and unsubscribe calls can @@ -94,28 +95,20 @@ struct flat_map output_type out; }; // take a copy of the values for each subscription - auto state = std::make_shared(initial, std::move(o)); + auto state = std::shared_ptr(new state_type(initial, std::move(o))); - ++state->subscriptions; - - composite_subscription cs; + composite_subscription outercs; // when the out observer is unsubscribed all the // inner subscriptions are unsubscribed as well - state->out.get_subscription().add(cs); - - cs.add(make_subscription([state](){ - if (--state->subscriptions == 0) { - std::unique_lock guard(state->lock); - state->out.on_completed(); - } - })); + state->out.get_subscription().add(outercs); + ++state->pendingCompletions; // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished state->source.subscribe( - cs, + outercs, // on_next [state](source_value_type st) { util::detail::maybe selectedCollection; @@ -127,25 +120,21 @@ struct flat_map return; } - ++state->subscriptions; - - composite_subscription cs; + composite_subscription innercs; // when the out observer is unsubscribed all the // inner subscriptions are unsubscribed as well - state->out.get_subscription().add(cs); + auto innercstoken = state->out.get_subscription().add(innercs); - cs.add(make_subscription([state](){ - if (--state->subscriptions == 0) { - std::unique_lock guard(state->lock); - state->out.on_completed(); - } + innercs.add(make_subscription([state, innercstoken](){ + state->out.get_subscription().remove(innercstoken); })); + ++state->pendingCompletions; // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue selectedCollection->subscribe( - cs, + innercs, // on_next [state, st](collection_value_type ct) { util::detail::maybe selectedResult; @@ -161,25 +150,29 @@ struct flat_map }, // on_error [state](std::exception_ptr e) { - // no need to track state->subscriptions - // after an error - complete will not be called. std::unique_lock guard(state->lock); state->out.on_error(e); }, //on_completed - [](){ + [state](){ + if (--state->pendingCompletions == 0) { + std::unique_lock guard(state->lock); + state->out.on_completed(); + } } ); }, // on_error [state](std::exception_ptr e) { - // no need to track state->subscriptions - // after an error - complete will not be called. std::unique_lock guard(state->lock); state->out.on_error(e); }, // on_completed - []() { + [state]() { + if (--state->pendingCompletions == 0) { + std::unique_lock guard(state->lock); + state->out.on_completed(); + } } ); } diff --git a/Rx/CPP/src/rxcpp/operators/rx-map.hpp b/Rx/CPP/src/rxcpp/operators/rx-map.hpp index b8f2207..939d6e3 100644 --- a/Rx/CPP/src/rxcpp/operators/rx-map.hpp +++ b/Rx/CPP/src/rxcpp/operators/rx-map.hpp @@ -51,7 +51,8 @@ struct map typedef observer output_type; struct state_type - : public values + : public std::enable_shared_from_this + , public values { state_type(values i, output_type oarg) : values(std::move(i)) @@ -61,7 +62,7 @@ struct map output_type out; }; // take a copy of the values for each subscription - auto state = std::make_shared(initial, std::move(o)); + auto state = std::shared_ptr(new state_type(initial, std::move(o))); state->source.subscribe( state->out.get_subscription(), diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/CPP/src/rxcpp/rx-predef.hpp index be88f04..81c2292 100644 --- a/Rx/CPP/src/rxcpp/rx-predef.hpp +++ b/Rx/CPP/src/rxcpp/rx-predef.hpp @@ -41,7 +41,7 @@ class is_observable template static void check(...); public: - static const bool value = std::is_convertible(0)), tag_observable>::value; + static const bool value = std::is_convertible::type>(0)), tag_observable>::value; }; } diff --git a/Rx/CPP/src/rxcpp/rx-subscription.hpp b/Rx/CPP/src/rxcpp/rx-subscription.hpp index f1d2329..ccb8e06 100644 --- a/Rx/CPP/src/rxcpp/rx-subscription.hpp +++ b/Rx/CPP/src/rxcpp/rx-subscription.hpp @@ -20,7 +20,7 @@ class is_subscription template static void check(...); public: - static const bool value = std::is_convertible(0)), tag_subscription>::value; + static const bool value = std::is_convertible::type>(0)), tag_subscription>::value; }; class dynamic_subscription : public subscription_base @@ -177,14 +177,16 @@ private: void remove(weak_subscription w) { std::unique_lock guard(lock); - auto s = w.lock(); - if (s) - { - auto end = std::end(subscriptions); - auto it = std::find(std::begin(subscriptions), end, s); - if (it != end) + if (issubscribed) { + auto s = w.lock(); + if (s) { - subscriptions.erase(it); + auto end = std::end(subscriptions); + auto it = std::find(std::begin(subscriptions), end, s); + if (it != end) + { + subscriptions.erase(it); + } } } } @@ -251,7 +253,7 @@ public: return state->add(std::move(s)); } void remove(weak_subscription w) const { - state->remove(w); + state->remove(std::move(w)); } void clear() const { state->clear(); diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/CPP/src/rxcpp/rx-test.hpp index a9db66d..946ec03 100644 --- a/Rx/CPP/src/rxcpp/rx-test.hpp +++ b/Rx/CPP/src/rxcpp/rx-test.hpp @@ -80,7 +80,7 @@ public: } }; -struct tag_test_observable : public tag_observable {}; +//struct tag_test_observable : public tag_observable {}; template class testable_observable @@ -90,7 +90,7 @@ class testable_observable typedef typename detail::test_subject_base::type test_subject; test_subject ts; - typedef tag_test_observable observable_tag; + //typedef tag_test_observable observable_tag; public: typedef typename detail::test_subject_base::recorded_type recorded_type; -- GitLab From 3c7aa2040c298353cffcd5f41fccfce5407d78c3 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sun, 2 Mar 2014 17:49:04 -0800 Subject: [PATCH 217/782] prep version 2 for release --- Rx/v2/license.txt | 15 ++++++++++ .../src/rxcpp/operators/rx-filter.hpp | 0 .../src/rxcpp/operators/rx-flat_map.hpp | 0 Rx/{CPP => v2}/src/rxcpp/operators/rx-map.hpp | 0 .../src/rxcpp/operators/rx-subscribe.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-includes.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-notification.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-observable.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-observer.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-operators.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-predef.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-scheduler.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-sources.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-subjects.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-subscription.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-test.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx-util.hpp | 0 Rx/{CPP => v2}/src/rxcpp/rx.hpp | 0 .../src/rxcpp/schedulers/rx-currentthread.hpp | 0 .../src/rxcpp/schedulers/rx-test.hpp | 0 .../src/rxcpp/schedulers/rx-virtualtime.hpp | 0 Rx/{CPP => v2}/src/rxcpp/sources/rx-range.hpp | 0 .../src/rxcpp/subjects/rx-subject.hpp | 0 .../test/v2 => v2/test}/operators/filter.cpp | 0 .../v2 => v2/test}/operators/flat_map.cpp | 0 Rx/{CPP/test/v2 => v2/test}/operators/map.cpp | 0 .../test/v2 => v2/test}/subjects/subject.cpp | 0 .../v2 => v2/test}/subscriptions/observer.cpp | 0 .../test}/subscriptions/subscription.cpp | 0 Rx/v2/test/test.cpp | 2 ++ projects/CMake/CMakeLists.txt | 28 ++++++++++--------- 31 files changed, 32 insertions(+), 13 deletions(-) create mode 100644 Rx/v2/license.txt rename Rx/{CPP => v2}/src/rxcpp/operators/rx-filter.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/operators/rx-flat_map.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/operators/rx-map.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/operators/rx-subscribe.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-includes.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-notification.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-observable.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-observer.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-operators.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-predef.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-scheduler.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-sources.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-subjects.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-subscription.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-test.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx-util.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/rx.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/schedulers/rx-currentthread.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/schedulers/rx-test.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/schedulers/rx-virtualtime.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/sources/rx-range.hpp (100%) rename Rx/{CPP => v2}/src/rxcpp/subjects/rx-subject.hpp (100%) rename Rx/{CPP/test/v2 => v2/test}/operators/filter.cpp (100%) rename Rx/{CPP/test/v2 => v2/test}/operators/flat_map.cpp (100%) rename Rx/{CPP/test/v2 => v2/test}/operators/map.cpp (100%) rename Rx/{CPP/test/v2 => v2/test}/subjects/subject.cpp (100%) rename Rx/{CPP/test/v2 => v2/test}/subscriptions/observer.cpp (100%) rename Rx/{CPP/test/v2 => v2/test}/subscriptions/subscription.cpp (100%) create mode 100644 Rx/v2/test/test.cpp diff --git a/Rx/v2/license.txt b/Rx/v2/license.txt new file mode 100644 index 0000000..5b47fbd --- /dev/null +++ b/Rx/v2/license.txt @@ -0,0 +1,15 @@ +Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +Microsoft Open Technologies would like to thank its contributors, a list +of whom are at http://rx.codeplex.com/wikipage?title=Contributors. + +Licensed under the Apache License, Version 2.0 (the "License"); you +may not use this file except in compliance with the License. You may +obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied. See the License for the specific language governing permissions +and limitations under the License. \ No newline at end of file diff --git a/Rx/CPP/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/operators/rx-filter.hpp rename to Rx/v2/src/rxcpp/operators/rx-filter.hpp diff --git a/Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/operators/rx-flat_map.hpp rename to Rx/v2/src/rxcpp/operators/rx-flat_map.hpp diff --git a/Rx/CPP/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/operators/rx-map.hpp rename to Rx/v2/src/rxcpp/operators/rx-map.hpp diff --git a/Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/operators/rx-subscribe.hpp rename to Rx/v2/src/rxcpp/operators/rx-subscribe.hpp diff --git a/Rx/CPP/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-includes.hpp rename to Rx/v2/src/rxcpp/rx-includes.hpp diff --git a/Rx/CPP/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-notification.hpp rename to Rx/v2/src/rxcpp/rx-notification.hpp diff --git a/Rx/CPP/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-observable.hpp rename to Rx/v2/src/rxcpp/rx-observable.hpp diff --git a/Rx/CPP/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-observer.hpp rename to Rx/v2/src/rxcpp/rx-observer.hpp diff --git a/Rx/CPP/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-operators.hpp rename to Rx/v2/src/rxcpp/rx-operators.hpp diff --git a/Rx/CPP/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-predef.hpp rename to Rx/v2/src/rxcpp/rx-predef.hpp diff --git a/Rx/CPP/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-scheduler.hpp rename to Rx/v2/src/rxcpp/rx-scheduler.hpp diff --git a/Rx/CPP/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-sources.hpp rename to Rx/v2/src/rxcpp/rx-sources.hpp diff --git a/Rx/CPP/src/rxcpp/rx-subjects.hpp b/Rx/v2/src/rxcpp/rx-subjects.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-subjects.hpp rename to Rx/v2/src/rxcpp/rx-subjects.hpp diff --git a/Rx/CPP/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-subscription.hpp rename to Rx/v2/src/rxcpp/rx-subscription.hpp diff --git a/Rx/CPP/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-test.hpp rename to Rx/v2/src/rxcpp/rx-test.hpp diff --git a/Rx/CPP/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx-util.hpp rename to Rx/v2/src/rxcpp/rx-util.hpp diff --git a/Rx/CPP/src/rxcpp/rx.hpp b/Rx/v2/src/rxcpp/rx.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/rx.hpp rename to Rx/v2/src/rxcpp/rx.hpp diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/schedulers/rx-currentthread.hpp rename to Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/schedulers/rx-test.hpp rename to Rx/v2/src/rxcpp/schedulers/rx-test.hpp diff --git a/Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/schedulers/rx-virtualtime.hpp rename to Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp diff --git a/Rx/CPP/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/sources/rx-range.hpp rename to Rx/v2/src/rxcpp/sources/rx-range.hpp diff --git a/Rx/CPP/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp similarity index 100% rename from Rx/CPP/src/rxcpp/subjects/rx-subject.hpp rename to Rx/v2/src/rxcpp/subjects/rx-subject.hpp diff --git a/Rx/CPP/test/v2/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp similarity index 100% rename from Rx/CPP/test/v2/operators/filter.cpp rename to Rx/v2/test/operators/filter.cpp diff --git a/Rx/CPP/test/v2/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp similarity index 100% rename from Rx/CPP/test/v2/operators/flat_map.cpp rename to Rx/v2/test/operators/flat_map.cpp diff --git a/Rx/CPP/test/v2/operators/map.cpp b/Rx/v2/test/operators/map.cpp similarity index 100% rename from Rx/CPP/test/v2/operators/map.cpp rename to Rx/v2/test/operators/map.cpp diff --git a/Rx/CPP/test/v2/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp similarity index 100% rename from Rx/CPP/test/v2/subjects/subject.cpp rename to Rx/v2/test/subjects/subject.cpp diff --git a/Rx/CPP/test/v2/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp similarity index 100% rename from Rx/CPP/test/v2/subscriptions/observer.cpp rename to Rx/v2/test/subscriptions/observer.cpp diff --git a/Rx/CPP/test/v2/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp similarity index 100% rename from Rx/CPP/test/v2/subscriptions/subscription.cpp rename to Rx/v2/test/subscriptions/subscription.cpp diff --git a/Rx/v2/test/test.cpp b/Rx/v2/test/test.cpp new file mode 100644 index 0000000..0c7c351 --- /dev/null +++ b/Rx/v2/test/test.cpp @@ -0,0 +1,2 @@ +#define CATCH_CONFIG_MAIN +#include "catch.hpp" diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 3c43324..b0f11d0 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -17,7 +17,9 @@ get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) set(TEST_DIR ${RXCPP_DIR}/Rx/CPP/test) -include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/CPP/src) +set(V2_TEST_DIR ${RXCPP_DIR}/Rx/v2/test) + +include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/CPP/src ${RXCPP_DIR}/Rx/v2/src) # define the sources of the self test set(TEST_SOURCES @@ -31,24 +33,24 @@ set(TEST_SOURCES ) add_executable(rxcpp_test ${TEST_SOURCES}) -# define the sources of the self test -set(TEST_SOURCES - ${TEST_DIR}/test.cpp - ${TEST_DIR}/v2/operators/flat_map.cpp - ${TEST_DIR}/v2/subscriptions/observer.cpp - ${TEST_DIR}/v2/subscriptions/subscription.cpp - ${TEST_DIR}/v2/operators/filter.cpp - ${TEST_DIR}/v2/operators/map.cpp - ${TEST_DIR}/v2/subjects/subject.cpp -) -add_executable(rxcppv2_test ${TEST_SOURCES}) - # define the sources of testbench set(TESTBENCH_SOURCES ${RXCPP_DIR}/Rx/CPP/testbench/testbench.cpp ) add_executable(testbench ${TESTBENCH_SOURCES}) +# define the sources of the self test +set(V2_TEST_SOURCES + ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/operators/flat_map.cpp + ${V2_TEST_DIR}/subscriptions/observer.cpp + ${V2_TEST_DIR}/subscriptions/subscription.cpp + ${V2_TEST_DIR}/operators/filter.cpp + ${V2_TEST_DIR}/operators/map.cpp + ${V2_TEST_DIR}/subjects/subject.cpp +) +add_executable(rxcppv2_test ${V2_TEST_SOURCES}) + # configure unit tests via CTest enable_testing() -- GitLab From fc01175023fd6e74635d6fe74f2567d4e8539e50 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 11 Mar 2014 07:33:17 -0700 Subject: [PATCH 218/782] subscriber --- Rx/v2/src/rxcpp/rx-regulator.hpp | 100 +++++++++++++++ Rx/v2/src/rxcpp/rx-subscriber.hpp | 205 ++++++++++++++++++++++++++++++ 2 files changed, 305 insertions(+) create mode 100644 Rx/v2/src/rxcpp/rx-regulator.hpp create mode 100644 Rx/v2/src/rxcpp/rx-subscriber.hpp diff --git a/Rx/v2/src/rxcpp/rx-regulator.hpp b/Rx/v2/src/rxcpp/rx-regulator.hpp new file mode 100644 index 0000000..d68fa12 --- /dev/null +++ b/Rx/v2/src/rxcpp/rx-regulator.hpp @@ -0,0 +1,100 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_REGULATOR_HPP) +#define RXCPP_RX_REGULATOR_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +struct tag_resumption {}; +struct resumption_base +{ + typedef tag_resumption resumption_tag; +}; +template +class is_resumption +{ + template + static typename C::resumption_tag* check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_resumption*>::value; +}; + +namespace detail { + +struct regulator_state_type + : public std::enable_shared_from_this +{ + regulator_state_type() + : isresumed(true) + { + } + rxsc::schedulable resumewith; + bool isresumed; +}; +typedef std::shared_ptr regulator_state; + +} + +// +// passed to subscribe to control the source +// the source must call is_resumed before each onnext +// the source must call resume_with when is_resumed returns false +// the schedulable passed to resume_with must implement a resumption policy; +// forward(undoes drop), unblock(undoes block), subscribe(undoes unsubscribe), +// drain(undoes buffer) +// +class resumption : public resumption_base +{ + detail::regulator_state state; +public: + resumption(){} + explicit resumption(detail::regulator_state st) + : state(st) + { + } + inline bool is_resumed() const { + return state ? state->isresumed : true; + } + inline void resume_with(rxsc::schedulable rw) { + // invalid to call when state is null. + state->resumewith = rw; + } +}; + +// +// owned by observer. the +// observer calls pause to stop the source. The +// observer calls resume when ready for the +// source to send more data. +// +class regulator +{ + detail::regulator_state state; +public: + regulator() + : state(new detail::regulator_state_type()) + { + } + inline void pause() { + state->isresumed = false; + } + inline void resume() { + state->isresumed = true; + auto resumewith = std::move(state->resumewith); + state->resumewith = nullptr; + resumewith.schedule(); + } + inline resumption get_resumption() { + return resumption(state); + } +}; + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp new file mode 100644 index 0000000..c36397a --- /dev/null +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -0,0 +1,205 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SUBSCRIBER_HPP) +#define RXCPP_RX_SUBSCRIBER_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +template> +class subscriber +{ + composite_subscription lifetime; + resumption controller; + Observer destination; + +public: + typedef typename composite_subscription::weak_subscription weak_subscription; + typedef typename composite_subscription::shared_subscription shared_subscription; + + subscriber() + { + } + subscriber(composite_subscription cs, resumption r, Observer o) + : lifetime(std::move(cs)) + , destination(std::move(o)) + , controller(std::move(r)) + { + } + + Observer get_observer() const { + return destination; + } + resumption get_resumption() const { + return controller; + } + composite_subscription get_subscription() const { + return lifetime; + } + + // resumption + // + bool is_resumed() const { + return controller.is_resumed(); + } + void resume_with(rxsc::schedulable rw) { + controller.resume_with(std::move(rw)); + } + + // observer + // + void on_next(T t) const { + destination.on_next(std::move(t)); + } + void on_error(std::exception_ptr e) const { + destination.on_error(e); + } + void on_completed() const { + destination.on_completed(); + } + + // composite_subscription + // + bool is_subscribed() const { + return lifetime.is_subscribed(); + } + weak_subscription add(shared_subscription s) const { + return lifetime.add(std::move(s)); + } + weak_subscription add(dynamic_subscription s) const { + return lifetime.add(std::move(s)); + } + void remove(weak_subscription w) const { + return lifetime.remove(std::move(w)); + } + void clear() const { + return lifetime.clear(); + } + void unsubscribe() const { + return lifetime.unsubscribe(); + } + +}; + +template +auto make_observer_resolved(ResolvedArgSet& rs) + -> observer::type::result_type, typename std::tuple_element<3, ResolvedArgSet>::type::result_type, typename std::tuple_element<4, ResolvedArgSet>::type::result_type>> { + return observer::type::result_type, typename std::tuple_element<3, ResolvedArgSet>::type::result_type, typename std::tuple_element<4, ResolvedArgSet>::type::result_type>>( + std::move(std::get<2>(rs).value), std::move(std::get<3>(rs).value), std::move(std::get<4>(rs).value)); + + static_assert(std::tuple_element<2, ResolvedArgSet>::type::is_arg, "onnext is a required parameter"); + static_assert(!(std::tuple_element<2, ResolvedArgSet>::type::is_arg && std::tuple_element<3, ResolvedArgSet>::type::is_arg) || std::tuple_element<2, ResolvedArgSet>::type::n + 1 == std::tuple_element<3, ResolvedArgSet>::type::n, "onnext, onerror parameters must be together and in order"); + static_assert(!(std::tuple_element<3, ResolvedArgSet>::type::is_arg && std::tuple_element<4, ResolvedArgSet>::type::is_arg) || std::tuple_element<3, ResolvedArgSet>::type::n + 1 == std::tuple_element<4, ResolvedArgSet>::type::n, "onerror, oncompleted parameters must be together and in order"); + static_assert(!(std::tuple_element<2, ResolvedArgSet>::type::is_arg && std::tuple_element<4, ResolvedArgSet>::type::is_arg && !std::tuple_element<3, ResolvedArgSet>::type::is_arg) || std::tuple_element<2, ResolvedArgSet>::type::n + 1 == std::tuple_element<4, ResolvedArgSet>::type::n, "onnext, oncompleted parameters must be together and in order"); +} + +template +auto make_subscriber_resolved(ResolvedArgSet& rs) + -> subscriber(rs))> { + return subscriber(rs))>(std::move(std::get<0>(rs).value), std::move(std::get<1>(rs).value), make_observer_resolved(rs)); + + static_assert(std::tuple_element<1, ResolvedArgSet>::type::is_arg, "resumption is a required parameter"); +} + +struct tag_subscription_resolution +{ + template + struct predicate : public is_subscription + { + }; + typedef composite_subscription default_type; +}; + +struct tag_resumption_resolution +{ + template + struct predicate : public is_resumption + { + }; + typedef resumption default_type; +}; + + +template +struct tag_onnext_resolution +{ + template + struct predicate : public is_on_next_of + { + }; + typedef detail::OnNextEmpty default_type; +}; + +struct tag_onerror_resolution +{ + template + struct predicate : public is_on_error + { + }; + typedef detail::OnErrorEmpty default_type; +}; + +struct tag_oncompleted_resolution +{ + template + struct predicate : public is_on_completed + { + }; + typedef detail::OnCompletedEmpty default_type; +}; + +// types to disambiguate +// subscriber with override for subscription, observer, resumption | +// optional subscriber + +// observer | on_next and optional on_error, on_completed + +// resumption + +// subscription | unsubscribe +// + +template +struct tag_subscriber_set + : public rxu::detail::tag_set, + rxu::detail::tag_set>>>>> +{ +}; + +template +auto make_subscriber(Arg0&& a0) + -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0)))) { + return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0))); +} +template +auto make_subscriber(Arg0&& a0, Arg1&& a1) + -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1)))) { + return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1))); +} +template +auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { + return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2))); +} +template +auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); +} +template +auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) + -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { + return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); +} +template +auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) + -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { + return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); +} + +} + +#endif -- GitLab From 34ccb0334a0b0d75fa703bfb326584f9342f1cf9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 11 Mar 2014 07:34:57 -0700 Subject: [PATCH 219/782] clean up --- Rx/v2/src/rxcpp/rx-observable.hpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index cf1bc87..26134b8 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -2,8 +2,8 @@ #pragma once -#if !defined(RXCPP_RX_SCHEDULER_OBSERVABLE_HPP) -#define RXCPP_RX_SCHEDULER_OBSERVABLE_HPP +#if !defined(RXCPP_RX_OBSERVABLE_HPP) +#define RXCPP_RX_OBSERVABLE_HPP #include "rx-includes.hpp" @@ -108,11 +108,12 @@ template class observable : public observable_base { + static_assert(std::is_same::value, "SourceOperator::value_type must be the same as T in observable"); + +protected: typedef observable this_type; mutable SourceOperator source_operator; - static_assert(std::is_same::value, "SourceOperator::value_type must be the same as T in observable"); - private: template friend class observable; -- GitLab From 42581391a48ac1f9e703bf13eaae1c4c158946e8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 11 Mar 2014 07:35:16 -0700 Subject: [PATCH 220/782] arg resolver --- Rx/v2/src/rxcpp/rx-util.hpp | 356 ++++++++++++++++++++++++++++++++++++ 1 file changed, 356 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index bb6e680..d797c7d 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -199,6 +199,362 @@ private: Function* function; }; +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = 5; + static const bool is_arg = true; + typedef Arg5 result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n prev_type; + typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; + result_type value; + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, result_type a, ...) + : value(std::move(a)) { + } +}; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<4, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = 4; + static const bool is_arg = true; + typedef Arg4 result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n prev_type; + typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; + result_type value; + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, result_type a, ...) + : value(std::move(a)) { + } +}; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<3, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = 3; + static const bool is_arg = true; + typedef Arg3 result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n prev_type; + typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; + result_type value; + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, result_type a, ...) + : value(std::move(a)) { + } +}; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<2, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = 2; + static const bool is_arg = true; + typedef Arg2 result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n prev_type; + typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; + result_type value; + arg_resolver_n(const Arg0&, const Arg1&, result_type a, ...) + : value(std::move(a)) { + } +}; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = 1; + static const bool is_arg = true; + typedef Arg1 result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n prev_type; + typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; + result_type value; + arg_resolver_n(const Arg0&, result_type a, ...) + : value(std::move(a)) { + } +}; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<0, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = 0; + static const bool is_arg = true; + typedef Arg0 result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n prev_type; + typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; + result_type value; + explicit arg_resolver_n(result_type a, ...) + : value(std::move(a)) { + } +}; + +template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ + static const int n = -1; + static const bool is_arg = false; + typedef Default result_type; + typedef arg_resolver_n this_type; + typedef this_type type; + result_type value; + explicit arg_resolver_n(...) + : value() { + } +}; + + +struct tag_unresolvable {}; +template class Predicate, class Default, class Arg0 = tag_unresolvable, class Arg1 = tag_unresolvable, class Arg2 = tag_unresolvable, class Arg3 = tag_unresolvable, class Arg4 = tag_unresolvable, class Arg5 = tag_unresolvable> +struct arg_resolver + : public arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> +{ +}; + + +template class Predicate, class Default> +auto resolve_arg() +-> decltype(typename arg_resolver::type()) { + return typename arg_resolver::type(); +} + +template class Predicate, class Default, + class Arg0> +auto resolve_arg(Arg0 a0) +-> decltype(typename arg_resolver::type(std::move(a0))) { + return typename arg_resolver::type(std::move(a0)); +} + +template class Predicate, class Default, + class Arg0, class Arg1> +auto resolve_arg(Arg0 a0, Arg1 a1) +-> decltype(typename arg_resolver::type( + std::move(a0), std::move(a1))) { + return typename arg_resolver::type( + std::move(a0), std::move(a1)); +} + +template class Predicate, class Default, + class Arg0, class Arg1, class Arg2> +auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2) +-> decltype(typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2))) { + return typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2)); +} + +template class Predicate, class Default, + class Arg0, class Arg1, class Arg2, class Arg3> +auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) +-> decltype(typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2), std::move(a3))) { + return typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2), std::move(a3)); +} + +template class Predicate, class Default, + class Arg0, class Arg1, class Arg2, class Arg3, class Arg4> +auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) +-> decltype(typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4))) { + return typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4)); +} + +template class Predicate, class Default, + class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) +-> decltype(typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), std::move(a5))) { + return typename arg_resolver::type( + std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), std::move(a5)); +} + +struct arg_resolver_term {}; + +// +// use to build a set of tags +// +template +struct tag_set : Base +{ + typedef Next next_tag; +}; + +template +struct arg_resolver_set; + +template<> +struct arg_resolver_set +{ + std::tuple<> operator()(...){ + return std::tuple<>(); + } +}; + +template +struct arg_resolver_set +{ + typedef arg_resolver_set next_set; + auto operator()() + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg()), + next_set()())) { + return std::tuple_cat( + std::make_tuple(resolve_arg()), + next_set()()); + } + template + auto operator()(Arg0&& a0) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0))), + next_set()(std::forward(a0)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0))), + next_set()(std::forward(a0))); + } + template + auto operator()(Arg0&& a0, Arg1&& a1) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), + next_set()(std::forward(a0), std::forward(a1)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), + next_set()(std::forward(a0), std::forward(a1))); + } + template + auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2))); + } + template + auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); + } + template + auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); + } + template + auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), + next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); + } +}; + +std::tuple<> resolve_arg_set(arg_resolver_term&&, ...){ + return std::tuple<>(); +} + +template +auto resolve_arg_set(Tag&&) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg()), + resolve_arg_set(typename Tag::next_tag()))) { + return std::tuple_cat( + std::make_tuple(resolve_arg()), + resolve_arg_set(typename Tag::next_tag())); +} +template +auto resolve_arg_set(Tag&&, Arg0&& a0) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0))); +} +template +auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1))); +} +template +auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2))); +} +template +auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); +} +template +auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); +} +template +auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), + resolve_arg_set(typename Tag::next_tag(), + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); +} + } } -- GitLab From 52d6a9cd64ec5256d7320f0dab106e1c944a8df7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 12 Mar 2014 17:00:44 -0700 Subject: [PATCH 221/782] start move to subscriber --- Rx/v2/src/rxcpp/rx-includes.hpp | 2 + Rx/v2/src/rxcpp/rx-observable.hpp | 6 +-- Rx/v2/src/rxcpp/rx-observer.hpp | 5 ++ Rx/v2/src/rxcpp/rx-regulator.hpp | 11 +++- Rx/v2/src/rxcpp/rx-subscriber.hpp | 43 +++++++++------- Rx/v2/src/rxcpp/rx-util.hpp | 74 +++++++++++++++++++-------- Rx/v2/test/subscriptions/observer.cpp | 55 ++++++++++++++++++++ 7 files changed, 152 insertions(+), 44 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 347e443..e210800 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -96,6 +96,8 @@ #include "rx-observer.hpp" #include "rx-notification.hpp" #include "rx-scheduler.hpp" +#include "rx-regulator.hpp" +#include "rx-subscriber.hpp" #include "rx-sources.hpp" #include "rx-subjects.hpp" #include "rx-operators.hpp" diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 26134b8..2dff6a0 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -126,7 +126,7 @@ private: return make_subscription(o); } - auto subscriber = [=]() { + auto safe_subscribe = [=]() { try { source_operator.on_subscribe(o); } @@ -142,11 +142,11 @@ private: if (rxsc::current_thread::is_schedule_required()) { auto sc = rxsc::make_current_thread(); sc->schedule([=](rxsc::action, rxsc::scheduler) { - subscriber(); + safe_subscribe(); return rxsc::make_action_empty(); }); } else { - subscriber(); + safe_subscribe(); } return make_subscription(o); diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index bdeccae..369339d 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -79,6 +79,11 @@ public: }; namespace detail { +template +struct OnNextEmpty +{ + void operator()(const T&) const {} +}; struct OnErrorEmpty { void operator()(std::exception_ptr) const {} diff --git a/Rx/v2/src/rxcpp/rx-regulator.hpp b/Rx/v2/src/rxcpp/rx-regulator.hpp index d68fa12..5cb4aff 100644 --- a/Rx/v2/src/rxcpp/rx-regulator.hpp +++ b/Rx/v2/src/rxcpp/rx-regulator.hpp @@ -9,6 +9,15 @@ namespace rxcpp { +// temp to get compiling +namespace schedulers { + struct schedulable + { + schedulable& operator=(std::nullptr_t) {return *this;}; + void schedule() {} + }; +} + struct tag_resumption {}; struct resumption_base { @@ -28,7 +37,7 @@ public: namespace detail { struct regulator_state_type - : public std::enable_shared_from_this + : public std::enable_shared_from_this { regulator_state_type() : isresumed(true) diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index c36397a..5234c5d 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -10,7 +10,7 @@ namespace rxcpp { template> -class subscriber +class subscriber : public observer_root, public subscription_base { composite_subscription lifetime; resumption controller; @@ -85,23 +85,30 @@ public: }; template -auto make_observer_resolved(ResolvedArgSet& rs) - -> observer::type::result_type, typename std::tuple_element<3, ResolvedArgSet>::type::result_type, typename std::tuple_element<4, ResolvedArgSet>::type::result_type>> { - return observer::type::result_type, typename std::tuple_element<3, ResolvedArgSet>::type::result_type, typename std::tuple_element<4, ResolvedArgSet>::type::result_type>>( - std::move(std::get<2>(rs).value), std::move(std::get<3>(rs).value), std::move(std::get<4>(rs).value)); - - static_assert(std::tuple_element<2, ResolvedArgSet>::type::is_arg, "onnext is a required parameter"); - static_assert(!(std::tuple_element<2, ResolvedArgSet>::type::is_arg && std::tuple_element<3, ResolvedArgSet>::type::is_arg) || std::tuple_element<2, ResolvedArgSet>::type::n + 1 == std::tuple_element<3, ResolvedArgSet>::type::n, "onnext, onerror parameters must be together and in order"); - static_assert(!(std::tuple_element<3, ResolvedArgSet>::type::is_arg && std::tuple_element<4, ResolvedArgSet>::type::is_arg) || std::tuple_element<3, ResolvedArgSet>::type::n + 1 == std::tuple_element<4, ResolvedArgSet>::type::n, "onerror, oncompleted parameters must be together and in order"); - static_assert(!(std::tuple_element<2, ResolvedArgSet>::type::is_arg && std::tuple_element<4, ResolvedArgSet>::type::is_arg && !std::tuple_element<3, ResolvedArgSet>::type::is_arg) || std::tuple_element<2, ResolvedArgSet>::type::n + 1 == std::tuple_element<4, ResolvedArgSet>::type::n, "onnext, oncompleted parameters must be together and in order"); +auto make_observer_resolved(ResolvedArgSet&& rs) + -> observer(std::forward(rs)).value), decltype (std::get<3>(std::forward(rs)).value), decltype (std::get<4>(std::forward(rs)).value)>> { + typedef static_observer(std::forward(rs)).value), decltype (std::get<3>(std::forward(rs)).value), decltype (std::get<4>(std::forward(rs)).value)> inner_type; + return observer(inner_type( + std::move(std::get<2>(std::forward(rs)).value), std::move(std::get<3>(std::forward(rs)).value), std::move(std::get<4>(std::forward(rs)).value))); + + typedef typename std::decay(std::forward(rs)))>::type rn_t; + typedef typename std::decay(std::forward(rs)))>::type re_t; + typedef typename std::decay(std::forward(rs)))>::type rc_t; + + static_assert(rn_t::is_arg, "onnext is a required parameter"); + static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); + static_assert(!(re_t::is_arg && rc_t::is_arg) || re_t::n + 1 == rc_t::n, "onerror, oncompleted parameters must be together and in order"); + static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); } template -auto make_subscriber_resolved(ResolvedArgSet& rs) - -> subscriber(rs))> { - return subscriber(rs))>(std::move(std::get<0>(rs).value), std::move(std::get<1>(rs).value), make_observer_resolved(rs)); +auto make_subscriber_resolved(ResolvedArgSet&& rs) + -> subscriber(std::forward(rs)))> { + return subscriber(std::forward(rs)))>(std::move(std::get<0>(std::forward(rs)).value), std::move(std::get<1>(std::forward(rs)).value), make_observer_resolved(std::forward(rs))); - static_assert(std::tuple_element<1, ResolvedArgSet>::type::is_arg, "resumption is a required parameter"); + typedef typename std::decay(std::forward(rs)))>::type rr_t; + + static_assert(rr_t::is_arg, "resumption is a required parameter"); } struct tag_subscription_resolution @@ -127,7 +134,7 @@ template struct tag_onnext_resolution { template - struct predicate : public is_on_next_of + struct predicate : public detail::is_on_next_of { }; typedef detail::OnNextEmpty default_type; @@ -136,7 +143,7 @@ struct tag_onnext_resolution struct tag_onerror_resolution { template - struct predicate : public is_on_error + struct predicate : public detail::is_on_error { }; typedef detail::OnErrorEmpty default_type; @@ -145,7 +152,7 @@ struct tag_onerror_resolution struct tag_oncompleted_resolution { template - struct predicate : public is_on_completed + struct predicate : public detail::is_on_completed { }; typedef detail::OnCompletedEmpty default_type; @@ -165,7 +172,7 @@ struct tag_subscriber_set rxu::detail::tag_set, rxu::detail::tag_set>>>>> + rxu::detail::tag_set>>>> { }; diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index d797c7d..91074d8 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -212,7 +212,7 @@ struct arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, result_type a, ...) + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, result_type a) : value(std::move(a)) { } }; @@ -227,7 +227,7 @@ struct arg_resolver_n<4, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, result_type a, ...) + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, result_type a, const Arg5&) : value(std::move(a)) { } }; @@ -242,7 +242,7 @@ struct arg_resolver_n<3, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, result_type a, ...) + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, result_type a, const Arg4&, const Arg5&) : value(std::move(a)) { } }; @@ -257,7 +257,7 @@ struct arg_resolver_n<2, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, result_type a, ...) + arg_resolver_n(const Arg0&, const Arg1&, result_type a, const Arg3&, const Arg4&, const Arg5&) : value(std::move(a)) { } }; @@ -272,7 +272,7 @@ struct arg_resolver_n<1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, result_type a, ...) + arg_resolver_n(const Arg0&, result_type a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) : value(std::move(a)) { } }; @@ -287,7 +287,7 @@ struct arg_resolver_n<0, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - explicit arg_resolver_n(result_type a, ...) + arg_resolver_n(result_type a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) : value(std::move(a)) { } }; @@ -301,7 +301,7 @@ struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5 typedef arg_resolver_n this_type; typedef this_type type; result_type value; - explicit arg_resolver_n(...) + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) : value() { } }; @@ -317,51 +317,51 @@ struct arg_resolver template class Predicate, class Default> auto resolve_arg() --> decltype(typename arg_resolver::type()) { - return typename arg_resolver::type(); +-> decltype(typename arg_resolver::type(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + return typename arg_resolver::type(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0> auto resolve_arg(Arg0 a0) --> decltype(typename arg_resolver::type(std::move(a0))) { - return typename arg_resolver::type(std::move(a0)); +-> decltype(typename arg_resolver::type(std::move(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + return typename arg_resolver::type(std::move(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1> auto resolve_arg(Arg0 a0, Arg1 a1) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1))) { + std::move(a0), std::move(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1)); + std::move(a0), std::move(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2> auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2))) { + std::move(a0), std::move(a1), std::move(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2)); + std::move(a0), std::move(a1), std::move(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3> auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3))) { + std::move(a0), std::move(a1), std::move(a2), std::move(a3), tag_unresolvable(), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3)); + std::move(a0), std::move(a1), std::move(a2), std::move(a3), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4> auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4))) { + std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4)); + std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), tag_unresolvable()); } template class Predicate, class Default, @@ -390,7 +390,7 @@ struct arg_resolver_set; template<> struct arg_resolver_set { - std::tuple<> operator()(...){ + inline std::tuple<> operator()(...){ return std::tuple<>(); } }; @@ -399,7 +399,7 @@ template struct arg_resolver_set { typedef arg_resolver_set next_set; - auto operator()() + inline auto operator()() -> decltype(std::tuple_cat( std::make_tuple(resolve_arg()), next_set()())) { @@ -463,7 +463,37 @@ struct arg_resolver_set } }; -std::tuple<> resolve_arg_set(arg_resolver_term&&, ...){ +inline std::tuple<> resolve_arg_set(arg_resolver_term&&) { + return std::tuple<>(); +} + +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& ) { + return std::tuple<>(); +} + +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& ) { + return std::tuple<>(); +} + +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& ) { + return std::tuple<>(); +} + +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& ) { + return std::tuple<>(); +} + +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& , Arg4&& ) { + return std::tuple<>(); +} + +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& , Arg4&& , Arg5&& ) { return std::tuple<>(); } diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 25150c4..5536dc0 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -3,6 +3,61 @@ namespace rx=rxcpp; #include "catch.hpp" +SCENARIO("subscriber traits", "[observer][traits]"){ + GIVEN("given some subscriber types"){ + int result = 0; + auto next = [&result](int i){result += i;}; + auto error = [&result](std::exception_ptr){result += 10;}; + auto completed = [&result](){result += 100;}; +// auto ra = rx::rxu::detail::arg_resolver_n<0, rx::tag_resumption_resolution::template predicate, typename rx::tag_resumption_resolution::default_type, rx::resumption, decltype(next), decltype(error), decltype(completed), rx::rxu::detail::tag_unresolvable, rx::rxu::detail::tag_unresolvable>(rx::resumption(), next, error, completed, rx::rxu::detail::tag_unresolvable(), rx::rxu::detail::tag_unresolvable()); +// auto ra = typename rx::rxu::detail::arg_resolver::type(rx::resumption(), next, error, completed, rx::rxu::detail::tag_unresolvable(), rx::rxu::detail::tag_unresolvable()); +// auto arg = rx::rxu::detail::resolve_arg(rx::resumption(), next, error, completed); +// auto argset = rx::rxu::detail::resolve_arg_set(rx::tag_subscriber_set(), rx::resumption(), next, error, completed); +// auto o = rx::make_observer_resolved(argset); +// auto scrbResult = rx::subscriber(std::move(std::get<0>(argset).value), std::move(std::get<1>(argset).value), o); +// static_assert(std::tuple_element<1, decltype(argset)>::type::is_arg, "resumption is a required parameter"); +// auto scrbResult = rx::make_subscriber_resolved(rx::rxu::detail::resolve_arg_set(rx::tag_subscriber_set(), rx::resumption(), next, error, completed)); +// auto scrbResult = rx::make_subscriber_resolved(argset); + auto scrbResult = rx::make_subscriber(rx::resumption(), next, error, completed); + + auto emptyNext = [](int){}; + auto scrb = rx::make_subscriber(rx::resumption(), emptyNext); + WHEN("tested"){ + THEN("is_observer value is true for subscriber"){ + REQUIRE(rx::is_observer::value); + } + THEN("is_subscription value is true for subscriber"){ + REQUIRE(rx::is_subscription::value); + } + } + WHEN("nothing is called"){ + THEN("static_observer result is 0"){ + REQUIRE(result == 0); + } + } + WHEN("onnext is called with 1"){ + THEN("subscriber result is 1"){ + scrbResult.on_next(1); + REQUIRE(result == 1); + } + } + WHEN("onnext is called with 1 after error"){ + THEN("subscriber result is 10"){ + scrbResult.on_error(std::current_exception()); + scrbResult.on_next(1); + REQUIRE(result == 10); + } + } + WHEN("onnext is called with 1 after completed"){ + THEN("subscriber result is 100"){ + scrbResult.on_completed(); + scrbResult.on_next(1); + REQUIRE(result == 100); + } + } + } +} + SCENARIO("observer traits", "[observer][traits]"){ GIVEN("given some observer types"){ auto emptyNext = [](int){}; -- GitLab From 64de52450d8a449257d06d2d33540acefa5a8728 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 13 Mar 2014 19:41:28 -0700 Subject: [PATCH 222/782] add override support to make_subscriber make_subscriber can take an existing subscriber and the some overrides and produce a new subscriber that reuses what has not been overridden. --- Rx/v2/src/rxcpp/rx-observable.hpp | 6 +- Rx/v2/src/rxcpp/rx-observer.hpp | 3 + Rx/v2/src/rxcpp/rx-subscriber.hpp | 112 ++++++++++++++++++++++++-- Rx/v2/src/rxcpp/rx-util.hpp | 2 +- Rx/v2/test/subscriptions/observer.cpp | 5 ++ 5 files changed, 117 insertions(+), 11 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 2dff6a0..6a9c02f 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -118,10 +118,12 @@ private: template friend class observable; - template - auto detail_subscribe(observer o, tag_observer&&) const + template + auto detail_subscribe(Observer o, tag_observer&&) const -> decltype(make_subscription(o)) { + static_assert(is_observer::value, "subscribe must be passed an observer"); + if (!o.is_subscribed()) { return make_subscription(o); } diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 369339d..c5cb7a2 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -489,6 +489,9 @@ public: ~observer() { } + observer() + { + } observer(inner_t inner) : inner(std::move(inner)) { diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 5234c5d..1d53ab5 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -9,8 +9,25 @@ namespace rxcpp { +struct tag_subscriber {}; +template +struct subscriber_base : public observer_root, public subscription_base, public resumption_base +{ + typedef tag_subscriber subscriber_tag; +}; +template +class is_subscriber +{ + template + static typename C::subscriber_tag* check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible(0)), tag_subscriber*>::value; +}; + template> -class subscriber : public observer_root, public subscription_base +class subscriber : public subscriber_base { composite_subscription lifetime; resumption controller; @@ -101,21 +118,97 @@ auto make_observer_resolved(ResolvedArgSet&& rs) static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); } +template +struct observer_selector; + +template +struct observer_selector +{ + template + static auto get_observer(Set&& rs) + -> decltype(std::get<5>(std::forward(rs))) { + return std::get<5>(std::forward(rs)); + } +}; +template +struct observer_selector +{ + template + static auto get_observer(Set&& rs) + -> decltype(make_observer_resolved(std::forward(rs))) { + return make_observer_resolved(std::forward(rs)); + } +}; +template +struct observer_selector +{ + template + static auto get_observer(Set&& rs) + -> decltype(std::get<6>(std::forward(rs)).value.get_observer()) { + return std::get<6>(std::forward(rs)).value.get_observer(); + } +}; + template -auto make_subscriber_resolved(ResolvedArgSet&& rs) - -> subscriber(std::forward(rs)))> { - return subscriber(std::forward(rs)))>(std::move(std::get<0>(std::forward(rs)).value), std::move(std::get<1>(std::forward(rs)).value), make_observer_resolved(std::forward(rs))); +auto select_observer(ResolvedArgSet&& rs) + -> decltype(observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs))) { + return observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs)); typedef typename std::decay(std::forward(rs)))>::type rr_t; + typedef typename std::decay(std::forward(rs)))>::type rn_t; + typedef typename std::decay(std::forward(rs)))>::type re_t; + typedef typename std::decay(std::forward(rs)))>::type rc_t; + typedef typename std::decay(std::forward(rs)))>::type ro_t; + typedef typename std::decay(std::forward(rs)))>::type rs_t; - static_assert(rr_t::is_arg, "resumption is a required parameter"); + static_assert(rs_t::is_arg || ro_t::is_arg || rn_t::is_arg, "at least one of; onnext, observer or subscriber is required"); + static_assert(int(ro_t::is_arg) + int(rn_t::is_arg) < 2, "onnext, onerror and oncompleted not allowed with an observer"); } +template +auto make_subscriber_resolved(ResolvedArgSet&& rs) + -> subscriber(std::forward(rs)))> { + auto rsub = std::get<0>(std::forward(rs)); + auto rr = std::get<1>(std::forward(rs)); + const auto& rscrbr = std::get<6>(std::forward(rs)); + auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : std::move(rr.value); + auto s = (rscrbr.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : std::move(rsub.value); + return subscriber(std::forward(rs)))>( + std::move(s), std::move(r), select_observer(std::forward(rs))); + + typedef typename std::decay::type rr_t; + typedef typename std::decay::type rs_t; + + static_assert(rs_t::is_arg || rr_t::is_arg, "at least one of; resumption or subscriber is a required parameter"); +} + +template +struct tag_subscriber_resolution +{ + template + struct predicate : public is_subscriber + { + }; + typedef subscriber> default_type; +}; + +template +struct tag_observer_resolution +{ + template + struct predicate + { + static const bool value = !is_subscriber::value && is_observer::value; + }; + typedef observer default_type; +}; + struct tag_subscription_resolution { template - struct predicate : public is_subscription + struct predicate { + static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; }; typedef composite_subscription default_type; }; @@ -123,8 +216,9 @@ struct tag_subscription_resolution struct tag_resumption_resolution { template - struct predicate : public is_resumption + struct predicate { + static const bool value = !is_subscriber::value && is_resumption::value; }; typedef resumption default_type; }; @@ -172,7 +266,9 @@ struct tag_subscriber_set rxu::detail::tag_set, rxu::detail::tag_set>>>> + rxu::detail::tag_set, + rxu::detail::tag_set>>>>>>> { }; diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 91074d8..53f1b3c 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -310,8 +310,8 @@ struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5 struct tag_unresolvable {}; template class Predicate, class Default, class Arg0 = tag_unresolvable, class Arg1 = tag_unresolvable, class Arg2 = tag_unresolvable, class Arg3 = tag_unresolvable, class Arg4 = tag_unresolvable, class Arg5 = tag_unresolvable> struct arg_resolver - : public arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> { + typedef typename arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>::type type; }; diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 5536dc0..588ffab 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -14,11 +14,16 @@ SCENARIO("subscriber traits", "[observer][traits]"){ // auto arg = rx::rxu::detail::resolve_arg(rx::resumption(), next, error, completed); // auto argset = rx::rxu::detail::resolve_arg_set(rx::tag_subscriber_set(), rx::resumption(), next, error, completed); // auto o = rx::make_observer_resolved(argset); +// auto o = rx::select_observer(argset); // auto scrbResult = rx::subscriber(std::move(std::get<0>(argset).value), std::move(std::get<1>(argset).value), o); // static_assert(std::tuple_element<1, decltype(argset)>::type::is_arg, "resumption is a required parameter"); // auto scrbResult = rx::make_subscriber_resolved(rx::rxu::detail::resolve_arg_set(rx::tag_subscriber_set(), rx::resumption(), next, error, completed)); // auto scrbResult = rx::make_subscriber_resolved(argset); auto scrbResult = rx::make_subscriber(rx::resumption(), next, error, completed); + auto scrbdup = rx::make_subscriber(scrbResult); + auto scrbop = rx::make_subscriber(scrbResult, next, error, completed); + auto scrbsharelifetime = rx::make_subscriber(scrbResult, scrbop.get_resumption(), scrbop.get_observer()); + auto scrbuniquelifetime = rx::make_subscriber(scrbResult, rx::composite_subscription()); auto emptyNext = [](int){}; auto scrb = rx::make_subscriber(rx::resumption(), emptyNext); -- GitLab From cb42db9eaa8dc288e42584d1ae892b8b811a28f9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 19 Mar 2014 18:11:40 -0700 Subject: [PATCH 223/782] switch subscribe from observer to subscriber --- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 33 +- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 72 ++-- Rx/v2/src/rxcpp/operators/rx-map.hpp | 34 +- Rx/v2/src/rxcpp/operators/rx-subscribe.hpp | 145 ++----- Rx/v2/src/rxcpp/rx-includes.hpp | 2 +- Rx/v2/src/rxcpp/rx-notification.hpp | 69 ++-- Rx/v2/src/rxcpp/rx-observable.hpp | 172 ++++---- Rx/v2/src/rxcpp/rx-observer.hpp | 446 ++++++--------------- Rx/v2/src/rxcpp/rx-predef.hpp | 13 + Rx/v2/src/rxcpp/rx-subscriber.hpp | 204 +++++----- Rx/v2/src/rxcpp/rx-subscription.hpp | 27 +- Rx/v2/src/rxcpp/rx-test.hpp | 46 ++- Rx/v2/src/rxcpp/rx-util.hpp | 81 ++-- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 121 ++++-- Rx/v2/src/rxcpp/sources/rx-range.hpp | 4 +- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 10 +- Rx/v2/test/operators/filter.cpp | 20 +- Rx/v2/test/operators/flat_map.cpp | 18 +- Rx/v2/test/operators/map.cpp | 23 +- Rx/v2/test/subjects/subject.cpp | 12 +- Rx/v2/test/subscriptions/observer.cpp | 6 +- projects/CMake/CMakeLists.txt | 4 +- 22 files changed, 717 insertions(+), 845 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index ee61646..28f2caa 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -16,23 +16,25 @@ namespace detail { template struct filter : public operator_base { - Observable source; - Predicate test; + typedef typename std::decay::type source_type; + typedef typename std::decay::type test_type; + source_type source; + test_type test; template static auto check(int) -> decltype((*(CP*)nullptr)(*(CT*)nullptr)); template static void check(...); - filter(Observable o, Predicate p) + filter(source_type o, test_type p) : source(std::move(o)) , test(std::move(p)) { - static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); + static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); } - template - void on_subscribe(observer o) { + template + void on_subscribe(Subscriber o) { source.subscribe( - o.get_subscription(), + o, // on_next [this, o](T t) { bool filtered = false; @@ -61,23 +63,24 @@ struct filter : public operator_base template class filter_factory { - Predicate predicate; + typedef typename std::decay::type test_type; + test_type predicate; public: - filter_factory(Predicate p) : predicate(std::move(p)) {} + filter_factory(test_type p) : predicate(std::move(p)) {} template - auto operator()(Observable source) - -> observable> { - return observable>( - filter(source, std::move(predicate))); + auto operator()(Observable&& source) + -> observable::type::value_type, filter::type::value_type, Observable, Predicate>> { + return observable::type::value_type, filter::type::value_type, Observable, Predicate>>( + filter::type::value_type, Observable, Predicate>(std::forward(source), std::move(predicate))); } }; } template -auto filter(Predicate p) +auto filter(Predicate&& p) -> detail::filter_factory { - return detail::filter_factory(std::move(p)); + return detail::filter_factory(std::forward(p)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 7ff88e1..a52d3c8 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -15,7 +15,11 @@ namespace detail { template struct flat_map_traits { - typedef typename Observable::value_type source_value_type; + typedef typename std::decay::type source_type; + typedef typename std::decay::type collection_selector_type; + typedef typename std::decay::type result_selector_type; + + typedef typename source_type::value_type source_value_type; struct tag_not_valid {}; template @@ -23,9 +27,9 @@ struct flat_map_traits { template static tag_not_valid collection_check(...); - static_assert(!std::is_same(0)), tag_not_valid>::value, "flat_map CollectionSelector must be a function with the signature observable(flat_map::source_value_type)"); + static_assert(!std::is_same(0)), tag_not_valid>::value, "flat_map CollectionSelector must be a function with the signature observable(flat_map::source_value_type)"); - typedef decltype((*(CollectionSelector*)nullptr)((*(source_value_type*)nullptr))) collection_type; + typedef decltype((*(collection_selector_type*)nullptr)((*(source_value_type*)nullptr))) collection_type; static_assert(is_observable::value, "flat_map CollectionSelector must return an observable"); @@ -36,9 +40,9 @@ struct flat_map_traits { template static tag_not_valid result_check(...); - static_assert(!std::is_same(0)), tag_not_valid>::value, "flat_map ResultSelector must be a function with the signature flat_map::value_type(flat_map::source_value_type, flat_map::collection_value_type)"); + static_assert(!std::is_same(0)), tag_not_valid>::value, "flat_map ResultSelector must be a function with the signature flat_map::value_type(flat_map::source_value_type, flat_map::collection_value_type)"); - typedef decltype((*(ResultSelector*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; + typedef decltype((*(result_selector_type*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; }; template @@ -48,39 +52,46 @@ struct flat_map typedef flat_map this_type; typedef flat_map_traits traits; + typedef typename traits::source_type source_type; + typedef typename traits::collection_selector_type collection_selector_type; + typedef typename traits::result_selector_type result_selector_type; + + typedef typename traits::source_value_type source_value_type; + typedef typename traits::collection_type collection_type; + typedef typename traits::collection_value_type collection_value_type; + struct values { - values(Observable o, CollectionSelector s, ResultSelector rs) + values(source_type o, collection_selector_type s, result_selector_type rs) : source(std::move(o)) , selectCollection(std::move(s)) , selectResult(std::move(rs)) { } - Observable source; - CollectionSelector selectCollection; - ResultSelector selectResult; + source_type source; + collection_selector_type selectCollection; + result_selector_type selectResult; }; values initial; - typedef typename traits::source_value_type source_value_type; - typedef typename traits::collection_type collection_type; - typedef typename traits::collection_value_type collection_value_type; - - flat_map(Observable o, CollectionSelector s, ResultSelector rs) + flat_map(source_type o, collection_selector_type s, result_selector_type rs) : initial(std::move(o), std::move(s), std::move(rs)) { } - template - void on_subscribe(observer o) { + template + void on_subscribe(Observer&& o) { + static_assert(is_observer::value, "subscribe must be passed an observer"); + + typedef typename std::decay::type output_type; - typedef observer output_type; struct state_type : public std::enable_shared_from_this , public values { state_type(values i, output_type oarg) : values(std::move(i)) + , pendingCompletions(0) , out(std::move(oarg)) { } @@ -95,19 +106,20 @@ struct flat_map output_type out; }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::move(o))); + auto state = std::shared_ptr(new state_type(initial, std::forward(o))); composite_subscription outercs; // when the out observer is unsubscribed all the // inner subscriptions are unsubscribed as well - state->out.get_subscription().add(outercs); + state->out.add(outercs); ++state->pendingCompletions; // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished state->source.subscribe( + state->out, outercs, // on_next [state](source_value_type st) { @@ -124,16 +136,17 @@ struct flat_map // when the out observer is unsubscribed all the // inner subscriptions are unsubscribed as well - auto innercstoken = state->out.get_subscription().add(innercs); + auto innercstoken = state->out.add(innercs); innercs.add(make_subscription([state, innercstoken](){ - state->out.get_subscription().remove(innercstoken); + state->out.remove(innercstoken); })); ++state->pendingCompletions; // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue selectedCollection->subscribe( + state->out, innercs, // on_next [state, st](collection_value_type ct) { @@ -181,29 +194,32 @@ struct flat_map template class flat_map_factory { - CollectionSelector selectorCollection; - ResultSelector selectorResult; + typedef typename std::decay::type collection_selector_type; + typedef typename std::decay::type result_selector_type; + + collection_selector_type selectorCollection; + result_selector_type selectorResult; public: - flat_map_factory(CollectionSelector s, ResultSelector rs) + flat_map_factory(collection_selector_type s, result_selector_type rs) : selectorCollection(std::move(rs)) , selectorResult(std::move(s)) { } template - auto operator()(Observable source) + auto operator()(Observable&& source) -> observable::value_type, flat_map> { return observable::value_type, flat_map>( - flat_map(source, std::move(selectorCollection), std::move(selectorResult))); + flat_map(std::forward(source), std::move(selectorCollection), std::move(selectorResult))); } }; } template -auto flat_map(CollectionSelector s, ResultSelector rs) +auto flat_map(CollectionSelector&& s, ResultSelector&& rs) -> detail::flat_map_factory { - return detail::flat_map_factory(std::move(s), std::move(rs)); + return detail::flat_map_factory(std::forward(s), std::forward(rs)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 939d6e3..91d6673 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -19,15 +19,18 @@ struct map { typedef map this_type; + typedef typename std::decay::type source_type; + typedef typename std::decay::type select_type; + struct values { - values(Observable o, Selector s) + values(source_type o, select_type s) : source(std::move(o)) , select(std::move(s)) { } - Observable source; - Selector select; + source_type source; + select_type select; }; values initial; @@ -39,17 +42,17 @@ struct map template static tag_not_valid check(...); - static_assert(!std::is_same(0)), tag_not_valid>::value, "map Selector must be a function with the signature map::value_type(map::source_value_type)"); + static_assert(!std::is_same(0)), tag_not_valid>::value, "map Selector must be a function with the signature map::value_type(map::source_value_type)"); - map(Observable o, Selector s) + map(source_type o, select_type s) : initial(std::move(o), std::move(s)) { } - template - void on_subscribe(observer o) { + template + void on_subscribe(Subscriber o) { - typedef observer output_type; + typedef Subscriber output_type; struct state_type : public std::enable_shared_from_this , public values @@ -65,7 +68,7 @@ struct map auto state = std::shared_ptr(new state_type(initial, std::move(o))); state->source.subscribe( - state->out.get_subscription(), + state->out, // on_next [state](typename this_type::source_value_type st) { util::detail::maybe selected; @@ -92,23 +95,24 @@ struct map template class map_factory { - Selector selector; + typedef typename std::decay::type select_type; + select_type selector; public: - map_factory(Selector p) : selector(std::move(p)) {} + map_factory(select_type p) : selector(std::move(p)) {} template - auto operator()(Observable source) + auto operator()(Observable&& source) -> observable::value_type, map> { return observable::value_type, map>( - map(source, std::move(selector))); + map(std::forward(source), std::move(selector))); } }; } template -auto map(Selector p) +auto map(Selector&& p) -> detail::map_factory { - return detail::map_factory(std::move(p)); + return detail::map_factory(std::forward(p)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp index 0a53734..cc25c1d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp @@ -13,118 +13,61 @@ namespace operators { namespace detail { -template -class subscribe_to_observer_factory -{ - Observer observer; -public: - subscribe_to_observer_factory(Observer o) : observer(std::move(o)) {} - template - auto operator()(Observable source) - -> decltype(source.subscribe(std::move(observer))) { - return source.subscribe(std::move(observer)); - } -}; -template -class subscribe_factory -{ - OnNext onnext; - OnError onerror; - OnCompleted oncompleted; -public: - subscribe_factory(OnNext n, OnError e, OnCompleted c) - : onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - {} - template - auto operator()(Observable source) - -> decltype(source.subscribe(make_observer(std::move(onnext), std::move(onerror), std::move(oncompleted)))) { - return source.subscribe(make_observer(std::move(onnext), std::move(onerror), std::move(oncompleted))); - } -}; -template -class subscribe_factory_chained +template +class subscribe_factory; + +template +class subscribe_factory> { - composite_subscription cs; - OnNext onnext; - OnError onerror; - OnCompleted oncompleted; + subscriber scrbr; public: - subscribe_factory_chained(OnNext n, OnError e, OnCompleted c) - : cs(std::move(cs)) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) + subscribe_factory(subscriber s) + : scrbr(std::move(s)) {} template - auto operator()(Observable source) - -> decltype(source.subscribe(make_observer(std::move(cs), std::move(onnext), std::move(onerror), std::move(oncompleted)))) { - return source.subscribe(make_observer(std::move(cs), std::move(onnext), std::move(onerror), std::move(oncompleted))); + auto operator()(Observable&& source) + -> decltype(std::forward(source).subscribe(std::move(scrbr))) { + return std::forward(source).subscribe(std::move(scrbr)); } }; -template -auto subscribe(Observer o, tag_observer&&) - -> subscribe_to_observer_factory { - return subscribe_to_observer_factory(std::move(o)); } -struct tag_function {}; -template -auto subscribe(OnNext n, tag_function&&) - -> subscribe_factory { - return subscribe_factory(std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); +template +auto subscribe(Arg0&& a0) + -> detail::subscribe_factory(std::forward(a0)))> { + return detail::subscribe_factory(std::forward(a0)))> + (make_subscriber(std::forward(a0))); } - -template -auto subscribe(OnNext n, OnError e, tag_function&&) - -> subscribe_factory { - return subscribe_factory(std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); +template +auto subscribe(Arg0&& a0, Arg1&& a1) + -> detail::subscribe_factory(std::forward(a0), std::forward(a1)))> { + return detail::subscribe_factory(std::forward(a0), std::forward(a1)))> + (make_subscriber(std::forward(a0), std::forward(a1))); } - -template -auto subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) - -> subscribe_factory { - return subscribe_factory(std::move(n), std::move(e), std::move(c)); -} - -template -auto subscribe(composite_subscription cs, OnNext n, tag_subscription&&) - -> subscribe_factory_chained { - return subscribe_factory_chained(std::move(cs), std::move(n), rxcpp::detail::OnErrorEmpty(), rxcpp::detail::OnCompletedEmpty()); -} - -template -auto subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) - -> subscribe_factory_chained { - return subscribe_factory_chained(std::move(cs), std::move(n), std::move(e), rxcpp::detail::OnCompletedEmpty()); -} - -} - -template -auto subscribe(Arg a) - -> decltype(detail::subscribe(std::move(a), typename std::conditional::value, tag_observer, detail::tag_function>::type())) { - return detail::subscribe(std::move(a), typename std::conditional::value, tag_observer, detail::tag_function>::type()); +template +auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2)))> { + return detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2)))> + (make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2))); } - -template -auto subscribe(Arg1 a1, Arg2 a2) - -> decltype(detail::subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { - return detail::subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); +template +auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))> { + return detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))> + (make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } - -template -auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) - -> decltype(detail::subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { - return detail::subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); +template +auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) + -> detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))> { + return detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))> + (make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } - -template -auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) - -> detail::subscribe_factory { - return detail::subscribe_factory(std::move(cs), std::move(n), std::move(e), std::move(c)); +template +auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) + -> detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))> { + return detail::subscribe_factory(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))> + (make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } namespace detail { @@ -133,9 +76,9 @@ class dynamic_factory { public: template - auto operator()(Observable source) - -> observable { - return observable(source); + auto operator()(Observable&& source) + -> observable::type::value_type> { + return observable::type::value_type>(std::forward(source)); } }; diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index e210800..9131716 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -94,10 +94,10 @@ #include "rx-predef.hpp" #include "rx-subscription.hpp" #include "rx-observer.hpp" -#include "rx-notification.hpp" #include "rx-scheduler.hpp" #include "rx-regulator.hpp" #include "rx-subscriber.hpp" +#include "rx-notification.hpp" #include "rx-sources.hpp" #include "rx-subjects.hpp" #include "rx-operators.hpp" diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index 503c392..dd1ff78 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -46,7 +46,7 @@ template struct notification_base : public std::enable_shared_from_this> { - typedef observer observer_type; + typedef subscriber observer_type; typedef std::shared_ptr> type; virtual ~notification_base() {} @@ -75,9 +75,9 @@ private: } virtual bool equals(const typename base::type& other) const { bool result = false; - other->accept(make_observer_dynamic([this, &result](T value) { + other->accept(make_subscriber(make_observer_dynamic([this, &result](T value) { result = this->value == value; - })); + }))); return result; } virtual void accept(const typename base::observer_type& o) const { @@ -103,9 +103,9 @@ private: virtual bool equals(const typename base::type& other) const { bool result = false; // not trying to compare exceptions - other->accept(make_observer_dynamic(nullptr, [&result](std::exception_ptr){ + other->accept(make_subscriber(make_observer_dynamic([](T){}, [&result](std::exception_ptr){ result = true; - })); + }))); return result; } virtual void accept(const typename base::observer_type& o) const { @@ -122,9 +122,9 @@ private: } virtual bool equals(const typename base::type& other) const { bool result = false; - other->accept(make_observer_dynamic(nullptr, nullptr, [&result](){ + other->accept(make_subscriber(make_observer_dynamic([](T){}, [&result](){ result = true; - })); + }))); return result; } virtual void accept(const typename base::observer_type& o) const { @@ -154,25 +154,48 @@ private: return std::make_shared(ep); } + struct on_next_factory + { + type operator()(T value) const { + return std::make_shared(std::move(value)); + } + }; + + struct on_completed_factory + { + type operator()() const { + return std::make_shared(); + } + }; + + struct on_error_factory + { + template + type operator()(Exception&& e) const { + return make_on_error(typename std::conditional< + std::is_same::type, std::exception_ptr>::value, + exception_ptr_tag, exception_tag>::type(), + std::forward(e)); + } + }; public: - static - type make_on_next(T value) { - return std::make_shared(std::move(value)); - } - static - type make_on_completed() { - return std::make_shared(); - } - template - static - type make_on_error(Exception&& e) { - return make_on_error(typename std::conditional< - std::is_same::type, std::exception_ptr>::value, - exception_ptr_tag, exception_tag>::type(), - std::forward(e)); - } + const static on_next_factory on_next; + const static on_completed_factory on_completed; + const static on_error_factory on_error; }; +template +//static +RXCPP_SELECT_ANY const typename notification::on_next_factory notification::on_next = notification::on_next_factory(); + +template +//static +RXCPP_SELECT_ANY const typename notification::on_completed_factory notification::on_completed = notification::on_completed_factory(); + +template +//static +RXCPP_SELECT_ANY const typename notification::on_error_factory notification::on_error = notification::on_error_factory(); + template bool operator == (const std::shared_ptr>& lhs, const std::shared_ptr>& rhs) { if (!lhs && !rhs) {return true;} diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 6a9c02f..7b1f336 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -20,10 +20,23 @@ struct is_operator_factory_for template static not_void check(...); - typedef decltype(check(0)) detail_result; + typedef decltype(check::type, typename std::decay::type>(0)) detail_result; static const bool value = !std::is_same::value; }; +template +struct has_on_subscribe_for +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CT*)nullptr).on_subscribe(*(CS*)nullptr)); + template + static not_void check(...); + + typedef decltype(check::type, T>(0)) detail_result; + static const bool value = std::is_same::value; +}; + } template @@ -33,7 +46,7 @@ class dynamic_observable struct state_type : public std::enable_shared_from_this { - typedef std::function)> onsubscribe_type; + typedef std::function)> onsubscribe_type; onsubscribe_type on_subscribe; }; @@ -48,8 +61,9 @@ class dynamic_observable } template - void construct(SO so, rxs::tag_source&&) { - state->on_subscribe = [so](observer o) mutable { + void construct(SO&& source, rxs::tag_source&&) { + typename std::decay::type so = std::forward(source); + state->on_subscribe = [so](subscriber o) mutable { so.on_subscribe(std::move(o)); }; } @@ -74,28 +88,29 @@ public: typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type()); } - void on_subscribe(observer o) const { + void on_subscribe(subscriber o) const { state->on_subscribe(std::move(o)); } - template - typename std::enable_if::type, observer>::value, void>::type - on_subscribe(Observer o) const { - auto so = std::make_shared(o); - state->on_subscribe(make_observer_dynamic( - so->get_subscription(), - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - })); + template + typename std::enable_if::type, observer>::value, void>::type + on_subscribe(Subscriber&& o) const { + auto so = std::make_shared::type>(std::forward(o)); + state->on_subscribe(make_subscriber( + *so, + make_observer_dynamic( + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + }))); } }; @@ -112,17 +127,23 @@ class observable protected: typedef observable this_type; - mutable SourceOperator source_operator; + typedef typename std::decay::type source_operator_type; + mutable source_operator_type source_operator; private: template friend class observable; - template - auto detail_subscribe(Observer o, tag_observer&&) const - -> decltype(make_subscription(o)) { + template + auto detail_subscribe(Subscriber&& scrbr) const + -> decltype(make_subscription(*(typename std::decay::type*)nullptr)) { - static_assert(is_observer::value, "subscribe must be passed an observer"); + typedef typename std::decay::type subscriber_type; + subscriber_type o = std::forward(scrbr); + + static_assert(is_observer::value, "subscribe must be passed an observer"); + static_assert(std::is_same::value && std::is_convertible::value, "the value types in the sequence must match or be convertible"); + static_assert(detail::has_on_subscribe_for::value, "inner must have on_subscribe method that accepts this subscriber "); if (!o.is_subscribed()) { return make_subscription(o); @@ -154,51 +175,20 @@ private: return make_subscription(o); } - struct tag_function {}; - template - auto detail_subscribe(OnNext n, tag_function&&) const - -> decltype(make_subscription( make_observer(std::move(n)))) { - return subscribe( make_observer(std::move(n))); - } - - template - auto detail_subscribe(OnNext n, OnError e, tag_function&&) const - -> decltype(make_subscription( make_observer(std::move(n), std::move(e)))) { - return subscribe( make_observer(std::move(n), std::move(e))); - } - - template - auto detail_subscribe(OnNext n, OnError e, OnCompleted c, tag_function&&) const - -> decltype(make_subscription( make_observer(std::move(n), std::move(e), std::move(c)))) { - return subscribe( make_observer(std::move(n), std::move(e), std::move(c))); - } - - template - auto detail_subscribe(composite_subscription cs, OnNext n, tag_subscription&&) const - -> decltype(make_subscription( make_observer(std::move(cs), std::move(n)))) { - return subscribe( make_observer(std::move(cs), std::move(n))); - } - - template - auto detail_subscribe(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) const - -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e)))) { - return subscribe( make_observer(std::move(cs), std::move(n), std::move(e))); - } - public: typedef T value_type; - static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); + static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); observable() { } - explicit observable(const SourceOperator& o) + explicit observable(const source_operator_type& o) : source_operator(o) { } - explicit observable(SourceOperator&& o) + explicit observable(source_operator_type&& o) : source_operator(std::move(o)) { } @@ -228,54 +218,66 @@ public: return *this; } - template - auto subscribe(Arg a) const - -> decltype(detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type())) { - return detail_subscribe(std::move(a), typename std::conditional::value, tag_observer, tag_function>::type()); + template + auto subscribe(Arg0&& a0) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0)))) { + return detail_subscribe(make_subscriber(std::forward(a0))); + } + + template + auto subscribe(Arg0&& a0, Arg1&& a1) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1)))) { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1))); + } + + template + auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2)))) { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2))); } - template - auto subscribe(Arg1 a1, Arg2 a2) const - -> decltype(detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type())) { - return detail_subscribe(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, tag_function>::type()); + template + auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } - template - auto subscribe(Arg1 a1, Arg2 a2, Arg3 a3) const - -> decltype(detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type())) { - return detail_subscribe(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, tag_function>::type()); + template + auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } - template - auto subscribe(composite_subscription cs, OnNext n, OnError e, OnCompleted c) const - -> decltype(make_subscription( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c)))) { - return subscribe( make_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); + template + auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } template - auto filter(Predicate p) const + auto filter(Predicate&& p) const -> observable> { return observable>( - rxo::detail::filter(*this, std::move(p))); + rxo::detail::filter(*this, std::forward(p))); } template - auto map(Selector s) const + auto map(Selector&& s) const -> observable::value_type, rxo::detail::map> { return observable::value_type, rxo::detail::map>( - rxo::detail::map(*this, std::move(s))); + rxo::detail::map(*this, std::forward(s))); } template - auto flat_map(CollectionSelector s, ResultSelector rs) const + auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const -> observable::value_type, rxo::detail::flat_map> { return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::move(s), std::move(rs))); + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); } template auto op(OperatorFactory&& of) const - -> decltype(of(*(this_type*)nullptr)) { + -> decltype(of(*(const this_type*)nullptr)) { static_assert(detail::is_operator_factory_for::value, "Function passed for op() must have the signature Result(SourceObservable)"); return of(*this); } diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index c5cb7a2..8d2ddcf 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -51,7 +51,7 @@ public: using std::swap; swap(s, o.s); } - typename this_type::subscription_type get_subscription() { + const typename this_type::subscription_type& get_subscription() const { return s; } bool is_subscribed() const { @@ -75,7 +75,7 @@ class is_observer template static void check(...); public: - static const bool value = std::is_convertible(0)), tag_observer>::value; + static const bool value = std::is_convertible::type>(0)), tag_observer>::value; }; namespace detail { @@ -102,7 +102,7 @@ struct is_on_next_of template static not_void check(...); - typedef decltype(check(0)) detail_result; + typedef decltype(check::type>(0)) detail_result; static const bool value = std::is_same::value; }; @@ -115,7 +115,7 @@ struct is_on_error template static not_void check(...); - static const bool value = std::is_same(0)), void>::value; + static const bool value = std::is_same::type>(0)), void>::value; }; template @@ -127,7 +127,7 @@ struct is_on_completed template static not_void check(...); - static const bool value = std::is_same(0)), void>::value; + static const bool value = std::is_same::type>(0)), void>::value; }; } @@ -147,215 +147,17 @@ private: on_error_t onerror; on_completed_t oncompleted; - struct tag_this_type {}; - struct tag_function {}; - - template - struct resolve_tag - { - typedef typename std::conditional::type, dynamic_observer>::value, tag_this_type, - typename std::conditional::value, tag_subscription, tag_function>::type - >::type type; - }; - - template::type> - struct resolve_cs; - template - struct resolve_cs - { - auto operator()(const Arg& a) - -> decltype(a.cs) { - return a.cs; - } - auto operator()(Arg&& a) - -> decltype(a.cs) { - return std::move(a.cs); - } - }; - template - struct resolve_cs - { - Arg operator()(Arg a) { - return std::move(a); - } - }; - template - struct resolve_cs - { - composite_subscription operator()(const Arg& a) { - return composite_subscription(); - } - }; - - template::type> - struct resolve_onnext; - template - struct resolve_onnext - { - auto operator()(const Arg& a) - -> decltype(a.onnext) { - return a.onnext; - } - auto operator()(Arg&& a) - -> decltype(a.onnext) { - return std::move(a.onnext); - } - }; - template - struct resolve_onnext - { - template - on_next_t operator()(const Arg1& a1) { - return on_next_t(); - } - template - Arg2 operator()(const Arg1&, Arg2 a2) { - static_assert(detail::is_on_next_of::value || std::is_same::value, - "Function supplied for on_next must be a function with the signature void(T);"); - return std::move(a2); - } - }; - template - struct resolve_onnext - { - template - Arg1 operator()(Arg1 a1) { - static_assert(detail::is_on_next_of::value || std::is_same::value, - "Function supplied for on_next must be a function with the signature void(T);"); - return std::move(a1); - } - template - Arg operator()(Arg1 a1, const Arg2&) { - static_assert(detail::is_on_next_of::value || std::is_same::value, - "Function supplied for on_next must be a function with the signature void(T);"); - return std::move(a1); - } - }; - - template::type> - struct resolve_onerror; - template - struct resolve_onerror - { - auto operator()(const Arg& a) - -> decltype(a.onerror) { - return a.onerror; - } - auto operator()(Arg&& a) - -> decltype(a.onerror) { - return std::move(a.onerror); - } - }; - template - struct resolve_onerror - { - template - on_error_t operator()(const Arg1& a1) { - return on_error_t(); - } - template - Arg2 operator()(const Arg1&, Arg2 a2) { - static_assert(detail::is_on_error::value || std::is_same::value, - "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); - return std::move(a2); - } - }; - template - struct resolve_onerror - { - template - on_error_t operator()(const Arg1& a1) { - return on_error_t(); - } - template - Arg1 operator()(Arg1 a1, const Arg2&) { - static_assert(detail::is_on_error::value || std::is_same::value, - "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); - return std::move(a1); - } - }; - - template::type> - struct resolve_oncompleted; - template - struct resolve_oncompleted - { - auto operator()(const Arg& a) - -> decltype(a.oncompleted) { - return a.oncompleted; - } - auto operator()(Arg&& a) - -> decltype(a.oncompleted) { - return std::move(a.oncompleted); - } - }; - template - struct resolve_oncompleted - { - template - on_completed_t operator()(const Arg1& a1) { - return on_completed_t(); - } - template - Arg2 operator()(const Arg1&, Arg2 a2) { - static_assert(detail::is_on_completed::value || std::is_same::value, - "Function supplied for on_completed must be a function with the signature void();"); - return std::move(a2); - } - }; - template - struct resolve_oncompleted - { - template - on_completed_t operator()(const Arg1& a1) { - return on_completed_t(); - } - template - Arg1 operator()(Arg1 a1, const Arg2&) { - static_assert(detail::is_on_completed::value || std::is_same::value, - "Function supplied for on_completed must be a function with the signature void();"); - return std::move(a1); - } - }; - public: dynamic_observer() { } - template - explicit dynamic_observer(Arg a) - : base_type(resolve_cs()(a)) - , onnext(resolve_onnext()(a)) - , onerror(resolve_onerror()(a)) - , oncompleted(resolve_oncompleted()(a)) - { - } - - template - dynamic_observer(Arg1 a1, Arg2 a2) - : base_type(resolve_cs()(a1)) - , onnext(resolve_onnext()(a1, a2)) - , onerror(resolve_onerror()(a2, on_error_t())) - , oncompleted(resolve_oncompleted()(on_completed_t(), on_completed_t())) - { - } - - template - dynamic_observer(Arg1 a1, Arg2 a2, Arg3 a3) - : base_type(resolve_cs()(a1)) - , onnext(resolve_onnext()(a1, a2)) - , onerror(resolve_onerror()(a2, a3)) - , oncompleted(resolve_oncompleted()(a3, on_completed_t())) - { - } - template - dynamic_observer(composite_subscription cs, OnNext n, OnError e, OnCompleted c) + dynamic_observer(composite_subscription cs, OnNext&& n, OnError&& e, OnCompleted&& c) : base_type(std::move(cs)) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) + , onnext(std::forward(n)) + , onerror(std::forward(e)) + , oncompleted(std::forward(c)) { static_assert(detail::is_on_next_of::value || std::is_same::value, "Function supplied for on_next must be a function with the signature void(T);"); @@ -394,13 +196,14 @@ public: } }; -template +template class static_observer : public observer_base { public: - typedef OnNext on_next_t; - typedef OnError on_error_t; - typedef OnCompleted on_completed_t; + typedef static_observer this_type; + typedef typename std::decay::type on_next_t; + typedef typename std::decay::type on_error_t; + typedef typename std::decay::type on_completed_t; private: on_next_t onnext; @@ -412,39 +215,32 @@ public: static_assert(detail::is_on_error::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); static_assert(detail::is_on_completed::value, "Function supplied for on_completed must be a function with the signature void();"); - explicit static_observer(on_next_t n = on_next_t(), on_error_t e = on_error_t(), on_completed_t c = on_completed_t()) - : observer_base(composite_subscription()) - , onnext(std::move(n)) - , onerror(std::move(e)) - , oncompleted(std::move(c)) - { - } - explicit static_observer(composite_subscription cs, on_next_t n = on_next_t(), on_error_t e = on_error_t(), on_completed_t c = on_completed_t()) + explicit static_observer(composite_subscription cs, on_next_t n, on_error_t e, on_completed_t c) : observer_base(std::move(cs)) , onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } - static_observer(const static_observer& o) + static_observer(const this_type& o) : observer_base(o) , onnext(o.onnext) , onerror(o.onerror) , oncompleted(o.oncompleted) { } - static_observer(static_observer&& o) + static_observer(this_type&& o) : observer_base(std::move(o)) , onnext(std::move(o.onnext)) , onerror(std::move(o.onerror)) , oncompleted(std::move(o.oncompleted)) { } - static_observer& operator=(static_observer o) { + static_observer& operator=(this_type o) { swap(o); return *this; } - void swap(static_observer& o) { + void swap(this_type& o) { using std::swap; observer_base::swap(o); swap(onnext, o.onnext); @@ -466,8 +262,8 @@ public: template class observer : public observer_root { - typedef observer this_type; - typedef typename std::conditional::value, I, dynamic_observer>::type inner_t; + typedef observer this_type; + typedef typename std::conditional::value, typename std::decay::type, dynamic_observer>::type inner_t; struct detacher { @@ -515,7 +311,7 @@ public: inner.on_completed(); } } - typename this_type::subscription_type get_subscription() { + const typename this_type::subscription_type& get_subscription() const { return inner.get_subscription(); } bool is_subscribed() const { @@ -545,7 +341,7 @@ public: } void on_completed() const { } - typename this_type::subscription_type get_subscription() { + const typename this_type::subscription_type& get_subscription() const { static typename this_type::subscription_type result; result.unsubscribe(); return result; @@ -571,115 +367,135 @@ auto make_observer() namespace detail { -struct tag_require_observer {}; - -struct tag_require_function {}; - -template -auto make_observer(I i, tag_observer&&) - -> observer { - return observer(std::move(i)); +template +auto make_observer_resolved(ResolvedArgSet&& rs) + -> observer(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>> { + return make_observer_resolved(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>>(std::forward(rs)); } - -struct tag_function {}; -template -auto make_observer(OnNext n, tag_function&&) - -> observer> { - return observer>( - static_observer(std::move(n))); +template +auto make_observer_dynamic_resolved(ResolvedArgSet&& rs) + -> observer> { + return make_observer_resolved>(std::forward(rs)); } -template -auto make_observer(OnNext n, OnError e, tag_function&&) - -> observer> { - return observer>( - static_observer(std::move(n), std::move(e))); +template +auto make_observer_resolved(ResolvedArgSet&& rs) + -> observer { + typedef I inner_type; + return observer(inner_type( + std::get<0>(std::forward(rs)).value, + std::move(std::get<1>(std::forward(rs)).value), + std::move(std::get<2>(std::forward(rs)).value), + std::move(std::get<3>(std::forward(rs)).value))); + + typedef typename std::decay(std::forward(rs)))>::type rn_t; + typedef typename std::decay(std::forward(rs)))>::type re_t; + typedef typename std::decay(std::forward(rs)))>::type rc_t; + + static_assert(rn_t::is_arg, "onnext is a required parameter"); + static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); + static_assert(!(re_t::is_arg && rc_t::is_arg) || re_t::n + 1 == rc_t::n, "onerror, oncompleted parameters must be together and in order"); + static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); } -template -auto make_observer(OnNext n, OnError e, OnCompleted c, tag_function&&) - -> observer> { - return observer>( - static_observer(std::move(n), std::move(e), std::move(c))); -} +struct tag_subscription_resolution +{ + template + struct predicate + { + static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; + }; + typedef composite_subscription default_type; +}; -template -auto make_observer(composite_subscription cs, OnNext n, tag_subscription&&) - -> observer> { - return observer>( - static_observer(std::move(cs), std::move(n))); -} +template +struct tag_onnext_resolution +{ + template + struct predicate + { + static const bool value = is_on_next_of::value; + }; + typedef OnNextEmpty default_type; +}; -template -auto make_observer(composite_subscription cs, OnNext n, OnError e, tag_subscription&&) - -> observer> { - return observer>( - static_observer(std::move(cs), std::move(n), std::move(e))); -} +struct tag_onerror_resolution +{ + template + struct predicate + { + static const bool value = is_on_error::value; + }; + typedef OnErrorEmpty default_type; +}; -} +struct tag_oncompleted_resolution +{ + template + struct predicate + { + static const bool value = is_on_completed::value; + }; + typedef OnCompletedEmpty default_type; +}; -template -auto make_observer(Arg a) - -> decltype(detail::make_observer(std::move(a), typename std::conditional::value, tag_observer, detail::tag_require_observer>::type())) { - return detail::make_observer(std::move(a), typename std::conditional::value, tag_observer, detail::tag_require_observer>::type()); -} +// types to disambiguate +// on_next and optional on_error, on_completed + +// optional subscription +// -template -auto make_observer(Arg a) - -> decltype(detail::make_observer(std::move(a), typename std::conditional::value, detail::tag_require_function, detail::tag_function>::type())) { - return detail::make_observer(std::move(a), typename std::conditional::value, detail::tag_require_function, detail::tag_function>::type()); -} +template +struct tag_observer_set + : public rxu::detail::tag_set, + rxu::detail::tag_set>>> +{ +}; -template -auto make_observer(Arg1 a1, Arg2 a2) - -> decltype(detail::make_observer(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { - return detail::make_observer(std::move(a1), std::move(a2), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); -} -template -auto make_observer(Arg1 a1, Arg2 a2, Arg3 a3) - -> decltype(detail::make_observer(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type())) { - return detail::make_observer(std::move(a1), std::move(a2), std::move(a3), typename std::conditional::value, tag_subscription, detail::tag_function>::type()); } -template -auto make_observer(composite_subscription cs, OnNext n, OnError e, OnCompleted c) - -> observer> { - return observer>( - static_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); +template +auto make_observer(Arg0&& a0) + -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0)))) { + return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0))); } - -template -auto make_observer_dynamic(OnNext n) - -> observer { - return observer(dynamic_observer(std::move(n))); +template +auto make_observer(Arg0&& a0, Arg1&& a1) + -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1)))) { + return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1))); } -template -auto make_observer_dynamic(OnNext n, OnError e) - -> observer { - return observer(dynamic_observer(std::move(n), std::move(e))); +template +auto make_observer(Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { + return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2))); } -template -auto make_observer_dynamic(OnNext n, OnError e, OnCompleted c) - -> observer { - return observer(dynamic_observer(std::move(n), std::move(e), std::move(c))); +template +auto make_observer(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } -template -auto make_observer_dynamic(composite_subscription cs, OnNext n) - -> observer { - return observer(dynamic_observer(std::move(cs), std::move(n))); +template +auto make_observer_dynamic(Arg0&& a0) + -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0)))) { + return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0))); } -template -auto make_observer_dynamic(composite_subscription cs, OnNext n, OnError e) - -> observer { - return observer(dynamic_observer(std::move(cs), std::move(n), std::move(e))); +template +auto make_observer_dynamic(Arg0&& a0, Arg1&& a1) + -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1)))) { + return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1))); } -template -auto make_observer_dynamic(composite_subscription cs, OnNext n, OnError e, OnCompleted c) - -> observer { - return observer(dynamic_observer(std::move(cs), std::move(n), std::move(e), std::move(c))); +template +auto make_observer_dynamic(Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { + return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2))); +} +template +auto make_observer_dynamic(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } } diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 81c2292..0a25131 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -15,6 +15,19 @@ class dynamic_observer; template> class observer; +struct tag_subscriber {}; +template +class is_subscriber +{ + struct not_void {}; + template + static typename C::subscriber_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_subscriber*>::value; +}; + template class dynamic_observable; diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 1d53ab5..7bca7ad 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -9,29 +9,36 @@ namespace rxcpp { -struct tag_subscriber {}; template struct subscriber_base : public observer_root, public subscription_base, public resumption_base { typedef tag_subscriber subscriber_tag; }; -template -class is_subscriber -{ - template - static typename C::subscriber_tag* check(int); - template - static void check(...); -public: - static const bool value = std::is_convertible(0)), tag_subscriber*>::value; -}; template> class subscriber : public subscriber_base { + typedef subscriber this_type; + typedef typename std::decay::type observer_type; + composite_subscription lifetime; resumption controller; - Observer destination; + observer_type destination; + + struct detacher + { + ~detacher() + { + if (that) { + that->unsubscribe(); + } + } + detacher(const this_type* that) + : that(that) + { + } + const this_type* that; + }; public: typedef typename composite_subscription::weak_subscription weak_subscription; @@ -40,20 +47,30 @@ public: subscriber() { } - subscriber(composite_subscription cs, resumption r, Observer o) + template + subscriber(composite_subscription cs, resumption r, U&& o) : lifetime(std::move(cs)) - , destination(std::move(o)) , controller(std::move(r)) + , destination(std::forward(o)) { } - Observer get_observer() const { + const observer_type& get_observer() const { + return destination; + } + observer_type& get_observer() { return destination; } - resumption get_resumption() const { + const resumption& get_resumption() const { return controller; } - composite_subscription get_subscription() const { + resumption& get_resumption() { + return controller; + } + const composite_subscription& get_subscription() const { + return lifetime; + } + composite_subscription& get_subscription() { return lifetime; } @@ -69,13 +86,23 @@ public: // observer // void on_next(T t) const { - destination.on_next(std::move(t)); + if (is_subscribed()) { + detacher protect(this); + destination.on_next(std::move(t)); + protect.that = nullptr; + } } void on_error(std::exception_ptr e) const { - destination.on_error(e); + if (is_subscribed()) { + detacher protect(this); + destination.on_error(e); + } } void on_completed() const { - destination.on_completed(); + if (is_subscribed()) { + detacher protect(this); + destination.on_completed(); + } } // composite_subscription @@ -101,22 +128,7 @@ public: }; -template -auto make_observer_resolved(ResolvedArgSet&& rs) - -> observer(std::forward(rs)).value), decltype (std::get<3>(std::forward(rs)).value), decltype (std::get<4>(std::forward(rs)).value)>> { - typedef static_observer(std::forward(rs)).value), decltype (std::get<3>(std::forward(rs)).value), decltype (std::get<4>(std::forward(rs)).value)> inner_type; - return observer(inner_type( - std::move(std::get<2>(std::forward(rs)).value), std::move(std::get<3>(std::forward(rs)).value), std::move(std::get<4>(std::forward(rs)).value))); - - typedef typename std::decay(std::forward(rs)))>::type rn_t; - typedef typename std::decay(std::forward(rs)))>::type re_t; - typedef typename std::decay(std::forward(rs)))>::type rc_t; - - static_assert(rn_t::is_arg, "onnext is a required parameter"); - static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); - static_assert(!(re_t::is_arg && rc_t::is_arg) || re_t::n + 1 == rc_t::n, "onerror, oncompleted parameters must be together and in order"); - static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); -} +namespace detail { template struct observer_selector; @@ -126,8 +138,8 @@ struct observer_selector { template static auto get_observer(Set&& rs) - -> decltype(std::get<5>(std::forward(rs))) { - return std::get<5>(std::forward(rs)); + -> decltype(std::get<5>(std::forward(rs)).value) { + return std::get<5>(std::forward(rs)).value; } }; template @@ -136,6 +148,9 @@ struct observer_selector template static auto get_observer(Set&& rs) -> decltype(make_observer_resolved(std::forward(rs))) { + if (!std::get<0>(std::forward(rs)).value.is_subscribed()) { + abort(); + } return make_observer_resolved(std::forward(rs)); } }; @@ -144,20 +159,23 @@ struct observer_selector { template static auto get_observer(Set&& rs) - -> decltype(std::get<6>(std::forward(rs)).value.get_observer()) { - return std::get<6>(std::forward(rs)).value.get_observer(); + -> const decltype( std::get<6>(std::forward(rs)).value.get_observer())& { + return std::get<6>(std::forward(rs)).value.get_observer(); } }; template auto select_observer(ResolvedArgSet&& rs) - -> decltype(observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs))) { - return observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs)); + -> decltype(observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs))) { + if (!std::get<0>(std::forward(rs)).value.is_subscribed()) { + abort(); + } + return observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs)); - typedef typename std::decay(std::forward(rs)))>::type rr_t; - typedef typename std::decay(std::forward(rs)))>::type rn_t; - typedef typename std::decay(std::forward(rs)))>::type re_t; - typedef typename std::decay(std::forward(rs)))>::type rc_t; + typedef typename std::decay(std::forward(rs)))>::type rr_t; + typedef typename std::decay(std::forward(rs)))>::type rn_t; + typedef typename std::decay(std::forward(rs)))>::type re_t; + typedef typename std::decay(std::forward(rs)))>::type rc_t; typedef typename std::decay(std::forward(rs)))>::type ro_t; typedef typename std::decay(std::forward(rs)))>::type rs_t; @@ -166,20 +184,27 @@ auto select_observer(ResolvedArgSet&& rs) } template -auto make_subscriber_resolved(ResolvedArgSet&& rs) - -> subscriber(std::forward(rs)))> { - auto rsub = std::get<0>(std::forward(rs)); - auto rr = std::get<1>(std::forward(rs)); - const auto& rscrbr = std::get<6>(std::forward(rs)); - auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : std::move(rr.value); - auto s = (rscrbr.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : std::move(rsub.value); - return subscriber(std::forward(rs)))>( - std::move(s), std::move(r), select_observer(std::forward(rs))); - +auto make_subscriber_resolved(ResolvedArgSet&& rsArg) + -> subscriber(std::move(rsArg)))> { + const auto rs = std::forward(rsArg); + if (!std::get<0>(rs).value.is_subscribed()) { + abort(); + } + const auto rsub = std::get<0>(rs); + const auto rr = std::get<4>(rs); + const auto rscrbr = std::get<6>(rs); + const auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : rr.value; + const auto s = (rscrbr.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : rsub.value; + return subscriber(std::move(rsArg)))>( + s, r, select_observer(std::move(rs))); + +// at least for now do not enforce resolver +#if 0 typedef typename std::decay::type rr_t; typedef typename std::decay::type rs_t; static_assert(rs_t::is_arg || rr_t::is_arg, "at least one of; resumption or subscriber is a required parameter"); +#endif } template @@ -203,16 +228,6 @@ struct tag_observer_resolution typedef observer default_type; }; -struct tag_subscription_resolution -{ - template - struct predicate - { - static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; - }; - typedef composite_subscription default_type; -}; - struct tag_resumption_resolution { template @@ -224,34 +239,6 @@ struct tag_resumption_resolution }; -template -struct tag_onnext_resolution -{ - template - struct predicate : public detail::is_on_next_of - { - }; - typedef detail::OnNextEmpty default_type; -}; - -struct tag_onerror_resolution -{ - template - struct predicate : public detail::is_on_error - { - }; - typedef detail::OnErrorEmpty default_type; -}; - -struct tag_oncompleted_resolution -{ - template - struct predicate : public detail::is_on_completed - { - }; - typedef detail::OnCompletedEmpty default_type; -}; - // types to disambiguate // subscriber with override for subscription, observer, resumption | // optional subscriber + @@ -262,45 +249,48 @@ struct tag_oncompleted_resolution template struct tag_subscriber_set + // the first four must be the same as tag_observer_set or the indexing will fail : public rxu::detail::tag_set, rxu::detail::tag_set, rxu::detail::tag_set>>>>>>> { }; +} + template auto make_subscriber(Arg0&& a0) - -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0)))) { - return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0))); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0)))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0))); } template auto make_subscriber(Arg0&& a0, Arg1&& a1) - -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1)))) { - return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1))); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1)))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1))); } template auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { - return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2))); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2))); } template auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } template auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) - -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { - return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } template auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) - -> decltype(make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { - return make_subscriber_resolved(rxu::detail::resolve_arg_set(tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } } diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index ccb8e06..6adba54 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -57,7 +57,7 @@ public: template class static_subscription : public subscription_base { - typedef Unsubscribe unsubscribe_call_type; + typedef typename std::decay::type unsubscribe_call_type; unsubscribe_call_type unsubscribe_call; static_subscription() { @@ -83,7 +83,7 @@ public: template class subscription : public subscription_base { - typedef I inner_t; + typedef typename std::decay::type inner_t; inner_t inner; mutable bool issubscribed; public: @@ -120,17 +120,17 @@ inline auto make_subscription() return subscription(); } template -auto make_subscription(I i) +auto make_subscription(I&& i) -> typename std::enable_if::value, subscription>::type { - return subscription(std::move(i)); + return subscription(std::forward(i)); } template -auto make_subscription(Unsubscribe u) +auto make_subscription(Unsubscribe&& u) -> typename std::enable_if::value, subscription< static_subscription>>::type { return subscription< static_subscription>( - static_subscription(std::move(u))); + static_subscription(std::forward(u))); } class composite_subscription : public subscription_base @@ -222,24 +222,39 @@ public: composite_subscription() : state(std::make_shared()) { + if (!state) { + abort(); + } } composite_subscription(const composite_subscription& o) : state(o.state) { + if (!state) { + abort(); + } } composite_subscription(composite_subscription&& o) : state(std::move(o.state)) { + if (!state) { + abort(); + } } composite_subscription& operator=(const composite_subscription& o) { state = o.state; + if (!state) { + abort(); + } return *this; } composite_subscription& operator=(composite_subscription&& o) { state = std::move(o.state); + if (!state) { + abort(); + } return *this; } diff --git a/Rx/v2/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp index 946ec03..e519cf8 100644 --- a/Rx/v2/src/rxcpp/rx-test.hpp +++ b/Rx/v2/src/rxcpp/rx-test.hpp @@ -18,7 +18,7 @@ struct test_subject_base typedef rxn::recorded::type> recorded_type; typedef std::shared_ptr> type; - virtual void on_subscribe(observer) const =0; + virtual void on_subscribe(subscriber) const =0; virtual std::vector messages() const =0; virtual std::vector subscriptions() const =0; }; @@ -30,29 +30,35 @@ struct test_source explicit test_source(typename test_subject_base::type ts) : ts(std::move(ts)) { + if (!this->ts) abort(); } typename test_subject_base::type ts; - void on_subscribe(observer o) const { + void on_subscribe(subscriber o) const { ts->on_subscribe(std::move(o)); } - template - typename std::enable_if::type, observer>::value, void>::type - on_subscribe(Observer o) const { - auto so = std::make_shared(o); - ts->on_subscribe(make_observer_dynamic( - so->get_subscription(), - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - })); + template + typename std::enable_if::type, subscriber>::value, void>::type + on_subscribe(Subscriber&& o) const { + + static_assert(is_subscriber::value, "on_subscribe must be passed a subscriber."); + + auto so = std::make_shared::type>(std::forward(o)); + ts->on_subscribe( + make_subscriber( + *so, + make_observer_dynamic( + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + }))); } }; diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 53f1b3c..fa6efe9 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -139,16 +139,15 @@ public: if (is_set) { is_set = false; reinterpret_cast(&storage)->~T(); + std::fill_n(reinterpret_cast(&storage), sizeof(T), 0); } } - void reset(T value) { - if (is_set) { - *reinterpret_cast(&storage) = std::move(value); - } else { - new (reinterpret_cast(&storage)) T(std::move(value)); - is_set = true; - } + template + void reset(U&& value) { + reset(); + new (reinterpret_cast(&storage)) T(std::forward(value)); + is_set = true; } maybe& operator=(const T& other) { @@ -212,8 +211,9 @@ struct arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, result_type a) - : value(std::move(a)) { + template + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, R&& a) + : value(std::forward(a)) { } }; @@ -227,8 +227,9 @@ struct arg_resolver_n<4, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, result_type a, const Arg5&) - : value(std::move(a)) { + template + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, R&& a, const Arg5&) + : value(std::forward(a)) { } }; @@ -242,8 +243,9 @@ struct arg_resolver_n<3, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, result_type a, const Arg4&, const Arg5&) - : value(std::move(a)) { + template + arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, R&& a, const Arg4&, const Arg5&) + : value(std::forward(a)) { } }; @@ -257,8 +259,9 @@ struct arg_resolver_n<2, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, result_type a, const Arg3&, const Arg4&, const Arg5&) - : value(std::move(a)) { + template + arg_resolver_n(const Arg0&, const Arg1&, R&& a, const Arg3&, const Arg4&, const Arg5&) + : value(std::forward(a)) { } }; @@ -272,8 +275,9 @@ struct arg_resolver_n<1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(const Arg0&, result_type a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - : value(std::move(a)) { + template + arg_resolver_n(const Arg0&, R&& a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + : value(std::forward(a)) { } }; @@ -287,8 +291,9 @@ struct arg_resolver_n<0, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; - arg_resolver_n(result_type a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - : value(std::move(a)) { + template + arg_resolver_n(R&& a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + : value(std::forward(a)) { } }; @@ -311,7 +316,7 @@ struct tag_unresolvable {}; template class Predicate, class Default, class Arg0 = tag_unresolvable, class Arg1 = tag_unresolvable, class Arg2 = tag_unresolvable, class Arg3 = tag_unresolvable, class Arg4 = tag_unresolvable, class Arg5 = tag_unresolvable> struct arg_resolver { - typedef typename arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5>::type type; + typedef typename arg_resolver_n<5, Predicate, Default, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type>::type type; }; @@ -323,54 +328,54 @@ auto resolve_arg() template class Predicate, class Default, class Arg0> -auto resolve_arg(Arg0 a0) --> decltype(typename arg_resolver::type(std::move(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type(std::move(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); +auto resolve_arg(Arg0&& a0) +-> decltype(typename arg_resolver::type(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + return typename arg_resolver::type(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1> -auto resolve_arg(Arg0 a0, Arg1 a1) +auto resolve_arg(Arg0&& a0, Arg1&& a1) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + std::forward(a0), std::forward(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); + std::forward(a0), std::forward(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2> -auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2) +auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + std::forward(a0), std::forward(a1), std::forward(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); + std::forward(a0), std::forward(a1), std::forward(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3> -auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) +auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), tag_unresolvable(), tag_unresolvable())) { + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), tag_unresolvable(), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), tag_unresolvable(), tag_unresolvable()); + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4> -auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) +auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), tag_unresolvable())) { + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), tag_unresolvable())) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), tag_unresolvable()); + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -auto resolve_arg(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) +auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) -> decltype(typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), std::move(a5))) { + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))) { return typename arg_resolver::type( - std::move(a0), std::move(a1), std::move(a2), std::move(a3), std::move(a4), std::move(a5)); + std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)); } struct arg_resolver_term {}; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 250dbf6..cd3b7ff 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -28,30 +28,37 @@ public: typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - static - recorded_type on_next(long ticks, T value) + struct on_next_factory { - return recorded_type(ticks, notification_type::make_on_next(value)); - } - - static - recorded_type on_completed(long ticks) + recorded_type operator()(long ticks, T value) const { + return recorded_type(ticks, notification_type::on_next(value)); + } + }; + struct on_completed_factory { - return recorded_type(ticks, notification_type::make_on_completed()); - } - - template - static - recorded_type on_error(long ticks, Exception e) + recorded_type operator()(long ticks) const { + return recorded_type(ticks, notification_type::on_completed()); + } + }; + struct on_error_factory { - return recorded_type(ticks, notification_type::make_on_error(e)); - } + template + recorded_type operator()(long ticks, Exception&& e) const { + return recorded_type(ticks, notification_type::on_error(std::forward(e))); + } + }; + + static const on_next_factory on_next; + static const on_completed_factory on_completed; + static const on_error_factory on_error; - static - rxn::subscription subscribe(long subscribe, long unsubscribe) + struct subscribe_factory { - return rxn::subscription(subscribe, unsubscribe); - } + rxn::subscription operator()(long subscribe, long unsubscribe) const { + return rxn::subscription(subscribe, unsubscribe); + } + }; + static const subscribe_factory subscribe; private: ~messages(); @@ -86,27 +93,29 @@ public: using base::start; template - auto start(F createSource, long created, long subscribed, long unsubscribed) - -> rxt::testable_observer + auto start(F&& createSource, long created, long subscribed, long unsubscribed) + -> subscriber> { + typename std::decay::type createSrc = std::forward(createSource); + struct state_type : public std::enable_shared_from_this { - typedef decltype(createSource()) source_type; + typedef decltype(std::forward(createSrc)()) source_type; std::unique_ptr source; - rxt::testable_observer o; + subscriber> o; - explicit state_type(rxt::testable_observer o) + explicit state_type(subscriber> o) : source() , o(o) { } }; - std::shared_ptr state(new state_type(this->make_observer())); + std::shared_ptr state(new state_type(this->make_subscriber())); - schedule_absolute(created, make_action([createSource, state](action, scheduler) { - state->source.reset(new typename state_type::source_type(createSource())); + schedule_absolute(created, make_action([createSrc, state](action, scheduler) { + state->source.reset(new typename state_type::source_type(createSrc())); return make_action_empty(); })); schedule_absolute(subscribed, make_action([state](action, scheduler) { @@ -124,17 +133,17 @@ public: } template - auto start(F createSource, long unsubscribed) - -> rxt::testable_observer + auto start(F&& createSource, long unsubscribed) + -> subscriber> { - return start(std::move(createSource), created_time, subscribed_time, unsubscribed); + return start(std::forward(createSource), created_time, subscribed_time, unsubscribed); } template - auto start(F createSource) - -> rxt::testable_observer + auto start(F&& createSource) + -> subscriber> { - return start(std::move(createSource), created_time, subscribed_time, unsubscribed_time); + return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); } template @@ -157,8 +166,27 @@ public: template rxt::testable_observer make_observer(); + + template + subscriber> make_subscriber(); }; +template +//static +RXCPP_SELECT_ANY const typename test::messages::on_next_factory test::messages::on_next = test::messages::on_next_factory(); + +template +//static +RXCPP_SELECT_ANY const typename test::messages::on_completed_factory test::messages::on_completed = test::messages::on_completed_factory(); + +template +//static +RXCPP_SELECT_ANY const typename test::messages::on_error_factory test::messages::on_error = test::messages::on_error_factory(); + +template +//static +RXCPP_SELECT_ANY const typename test::messages::subscribe_factory test::messages::subscribe = test::messages::subscribe_factory(); + template class mock_observer : public rxt::detail::test_subject_base @@ -175,7 +203,7 @@ public: typename test::shared sc; std::vector m; - virtual void on_subscribe(observer) const { + virtual void on_subscribe(subscriber) const { abort(); } virtual std::vector subscriptions() const { @@ -193,30 +221,37 @@ rxt::testable_observer test::make_observer() typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - auto ts = std::make_shared>( - std::static_pointer_cast(shared_from_this())); + std::shared_ptr> ts(new mock_observer( + std::static_pointer_cast(shared_from_this()))); return rxt::testable_observer(ts, make_observer_dynamic( // on_next [ts](T value) { ts->m.push_back( - recorded_type(ts->sc->clock(), notification_type::make_on_next(value))); + recorded_type(ts->sc->clock(), notification_type::on_next(value))); }, // on_error [ts](std::exception_ptr e) { ts->m.push_back( - recorded_type(ts->sc->clock(), notification_type::make_on_error(e))); + recorded_type(ts->sc->clock(), notification_type::on_error(e))); }, // on_completed [ts]() { ts->m.push_back( - recorded_type(ts->sc->clock(), notification_type::make_on_completed())); + recorded_type(ts->sc->clock(), notification_type::on_completed())); })); } +template +subscriber> test::make_subscriber() +{ + auto to = this->make_observer(); + return rxcpp::make_subscriber(to.get_subscription(), to); +} + template class cold_observable : public rxt::detail::test_subject_base @@ -242,7 +277,7 @@ public: { } - virtual void on_subscribe(observer o) const { + virtual void on_subscribe(subscriber o) const { sv.push_back(rxn::subscription(sc->clock())); auto index = sv.size() - 1; @@ -272,8 +307,8 @@ public: template rxt::testable_observable test::make_cold_observable(std::vector>>> messages) { - return rxt::testable_observable(std::make_shared>( - std::static_pointer_cast(shared_from_this()), std::move(messages))); + auto co = std::shared_ptr>(new cold_observable(std::static_pointer_cast(shared_from_this()), std::move(messages))); + return rxt::testable_observable(co); } template @@ -283,7 +318,7 @@ class hot_observable typedef hot_observable this_type; typename test::shared sc; typedef rxn::recorded::type> recorded_type; - typedef observer observer_type; + typedef subscriber observer_type; mutable std::vector mv; mutable std::vector sv; mutable std::vector observers; diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index 9a44ba9..418c292 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -31,8 +31,8 @@ struct range : public source_base init.step = s; init.sc = sc; } - template - void on_subscribe(observer o) { + template + void on_subscribe(Subscriber o) { auto state = std::make_shared(init); state->sc->schedule(o.get_subscription(), [=](rxsc::action that, rxsc::scheduler){ if (state->remaining == 0) { diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index fafdb14..82b05e7 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -18,7 +18,7 @@ class multicast_observer : public observer_base { typedef observer_base base; - typedef observer observer_type; + typedef subscriber observer_type; typedef std::vector list_type; struct mode @@ -66,7 +66,7 @@ class multicast_observer std::copy_if( old->observers.begin(), old->observers.end(), std::inserter(observers, observers.end()), - [](const observer& o){ + [](const observer_type& o){ return o.is_subscribed(); }); } @@ -108,7 +108,7 @@ public: bool has_observers() const { return b->state->has_observers; } - void add(observer o) const { + void add(observer_type o) const { std::unique_lock guard(b->state->lock); switch (b->state->current) { case mode::Casting: @@ -148,7 +148,7 @@ public: c = b->completer; } for (auto& o : c->observers) { - o.on_next(std::move(t)); + o.on_next(t); } } } @@ -206,7 +206,7 @@ public: return observer>(s); } observable get_observable() const { - return make_dynamic_observable([this](observer o){ + return make_dynamic_observable([this](subscriber o){ this->s.add(std::move(o)); }); } diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index 2e202be..ad92bbb 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -89,7 +89,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ m::on_completed(600) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -110,7 +110,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ } -SCENARIO("where stops on disposal", "[where][filter][operators]"){ +SCENARIO("filter stops on disposal", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); typedef rxsc::test::messages m; @@ -165,7 +165,7 @@ SCENARIO("where stops on disposal", "[where][filter][operators]"){ m::on_next(390, 7) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -185,7 +185,7 @@ SCENARIO("where stops on disposal", "[where][filter][operators]"){ } } -SCENARIO("where stops on error", "[where][filter][operators]"){ +SCENARIO("filter stops on error", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); typedef rxsc::test::messages m; @@ -250,7 +250,7 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ m::on_error(600, ex), }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -270,7 +270,7 @@ SCENARIO("where stops on error", "[where][filter][operators]"){ } } -SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ +SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); typedef rxsc::test::messages m; @@ -339,7 +339,7 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ m::on_error(380, ex) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -359,7 +359,7 @@ SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ } } -SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ +SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); typedef rxsc::test::messages m; @@ -389,7 +389,7 @@ SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ }() ); - auto res = sc->make_observer(); + auto res = sc->make_subscriber(); rx::observable> ys; @@ -436,7 +436,7 @@ SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ m::on_next(390, 7) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 9e4c108..ffceaf4 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -18,8 +18,6 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ typedef rxsc::test::messages m; typedef rxsc::test::messages ms; - long invoked = 0; - m::recorded_type int_messages[] = { m::on_next(100, 4), m::on_next(200, 2), @@ -43,7 +41,11 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ auto res = sc->start( [&]() { return xs - .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) + .flat_map( + [&](int){ + return ys;}, + [](int, std::string s){ + return s;}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); } @@ -70,7 +72,7 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ ms::on_completed(850) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -105,8 +107,6 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ typedef rxsc::test::messages m; typedef rxsc::test::messages ms; - long invoked = 0; - m::recorded_type int_messages[] = { m::on_next(100, 4), m::on_next(200, 2), @@ -162,7 +162,7 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ ms::on_next(950, "foo") }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -198,8 +198,6 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ typedef rxsc::test::messages m; typedef rxsc::test::messages ms; - long invoked = 0; - m::recorded_type int_messages[] = { m::on_next(100, 4), m::on_next(200, 2), @@ -244,7 +242,7 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ ms::on_error(601, ex) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/map.cpp b/Rx/v2/test/operators/map.cpp index 397287c..61da39c 100644 --- a/Rx/v2/test/operators/map.cpp +++ b/Rx/v2/test/operators/map.cpp @@ -17,19 +17,22 @@ SCENARIO("map stops on completion", "[map][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = std::make_shared(); typedef rxsc::test::messages m; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; long invoked = 0; m::recorded_type messages[] = { - m::on_next(180, 1), - m::on_next(210, 2), - m::on_next(240, 3), - m::on_next(290, 4), - m::on_next(350, 5), - m::on_completed(400), - m::on_next(410, -1), - m::on_completed(420), - m::on_error(430, std::runtime_error("error on unsubscribed stream")) + on_next(180, 1), + on_next(210, 2), + on_next(240, 3), + on_next(290, 4), + on_next(350, 5), + on_completed(400), + on_next(410, -1), + on_completed(420), + on_error(430, std::runtime_error("error on unsubscribed stream")) }; auto xs = sc->make_hot_observable(messages); @@ -56,7 +59,7 @@ SCENARIO("map stops on completion", "[map][operators]"){ m::on_completed(400) }; auto required = rxu::to_vector(items); - auto actual = res.messages(); + auto actual = res.get_observer().messages(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index f1905a2..efa84e8 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -172,11 +172,11 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ rxsub::subject s; - auto results1 = sc->make_observer(); + auto results1 = sc->make_subscriber(); - auto results2 = sc->make_observer(); + auto results2 = sc->make_subscriber(); - auto results3 = sc->make_observer(); + auto results3 = sc->make_subscriber(); WHEN("multicasting an infinite source"){ @@ -213,7 +213,7 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ m::on_next(520, 7) }; auto required = rxu::to_vector(items); - auto actual = results1.messages(); + auto actual = results1.get_observer().messages(); REQUIRE(required == actual); } @@ -224,7 +224,7 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ m::on_next(630, 8) }; auto required = rxu::to_vector(items); - auto actual = results2.messages(); + auto actual = results2.get_observer().messages(); REQUIRE(required == actual); } @@ -233,7 +233,7 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ m::on_next(940, 11) }; auto required = rxu::to_vector(items); - auto actual = results3.messages(); + auto actual = results3.get_observer().messages(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 588ffab..42caf7b 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -66,7 +66,7 @@ SCENARIO("subscriber traits", "[observer][traits]"){ SCENARIO("observer traits", "[observer][traits]"){ GIVEN("given some observer types"){ auto emptyNext = [](int){}; - rx::dynamic_observer dob(emptyNext); + auto dob = rx::make_observer_dynamic(emptyNext); auto so = rx::make_observer(emptyNext); auto eo = rx::make_observer(); WHEN("tested"){ @@ -110,7 +110,7 @@ SCENARIO("non-observer traits", "[observer][traits]"){ SCENARIO("observers with subscription traits", "[observer][subscription][traits]"){ GIVEN("given some observer types"){ auto emptyNext = [](int){}; - rx::dynamic_observer dob(emptyNext); + auto dob = rx::make_observer_dynamic(emptyNext); auto so = rx::make_observer(emptyNext); auto eo = rx::make_observer(); WHEN("tested"){ @@ -133,7 +133,7 @@ SCENARIO("observer behavior", "[observer][traits]"){ auto next = [&result](int i){result += i;}; auto error = [&result](std::exception_ptr){result += 10;}; auto completed = [&result](){result += 100;}; - auto dob = rx::make_observer(rx::dynamic_observer(next, error, completed)); + auto dob = rx::make_observer_dynamic(next, error, completed); auto so = rx::make_observer(next, error, completed); auto eo = rx::make_observer(); WHEN("nothing is called"){ diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b0f11d0..74cfc08 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,12 +42,12 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp - ${V2_TEST_DIR}/operators/flat_map.cpp + ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp + ${V2_TEST_DIR}/operators/flat_map.cpp ${V2_TEST_DIR}/subscriptions/subscription.cpp ${V2_TEST_DIR}/operators/filter.cpp ${V2_TEST_DIR}/operators/map.cpp - ${V2_TEST_DIR}/subjects/subject.cpp ) add_executable(rxcppv2_test ${V2_TEST_SOURCES}) -- GitLab From 3ce422e73b636d17a9189b0096cbb15821a29f8e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 19 Mar 2014 23:18:54 -0700 Subject: [PATCH 224/782] fix a runtime crash --- Rx/v2/src/rxcpp/rx-observable.hpp | 10 ++++-- Rx/v2/src/rxcpp/rx-observer.hpp | 14 ++------ Rx/v2/src/rxcpp/rx-operators.hpp | 4 +-- Rx/v2/src/rxcpp/rx-predef.hpp | 38 +++++++++++++++++++++ Rx/v2/src/rxcpp/rx-sources.hpp | 4 +-- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 4 +-- Rx/v2/test/subjects/subject.cpp | 45 +++++++++++++------------ 7 files changed, 77 insertions(+), 42 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 7b1f336..ced294b 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -52,11 +52,13 @@ class dynamic_observable }; std::shared_ptr state; - void construct(const dynamic_observable& o, rxs::tag_source&&) { + template + void construct(const dynamic_observable& o, tag_dynamic_observable&&) { state = o.state; } - void construct(dynamic_observable&& o, rxs::tag_source&&) { + template + void construct(dynamic_observable&& o, tag_dynamic_observable&&) { state = std::move(o.state); } @@ -76,6 +78,8 @@ class dynamic_observable public: + typedef tag_dynamic_observable dynamic_observable_tag; + dynamic_observable() { } @@ -85,7 +89,7 @@ public: : state(std::make_shared()) { construct(std::forward(sof), - typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type()); + typename std::conditional::value, tag_dynamic_observable, typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type>::type()); } void on_subscribe(subscriber o) const { diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 8d2ddcf..f3e5181 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -10,7 +10,6 @@ namespace rxcpp { -struct tag_observer {}; template struct observer_root : public subscription_base { @@ -67,16 +66,6 @@ public: s.unsubscribe(); } }; -template -class is_observer -{ - template - static typename C::observer_tag check(int); - template - static void check(...); -public: - static const bool value = std::is_convertible::type>(0)), tag_observer>::value; -}; namespace detail { template @@ -136,10 +125,11 @@ template class dynamic_observer : public observer_base { public: + typedef tag_dynamic_observer dynamic_observer_tag; + typedef std::function on_next_t; typedef std::function on_error_t; typedef std::function on_completed_t; - private: typedef observer_base base_type; diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index aa48e8c..a6071c9 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -22,11 +22,11 @@ template class is_operator { template - static typename C::operator_tag check(int); + static typename C::operator_tag* check(int); template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_operator>::value; + static const bool value = std::is_convertible::type>(0)), tag_operator*>::value; }; } diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 0a25131..5779f79 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -15,6 +15,31 @@ class dynamic_observer; template> class observer; +struct tag_observer {}; +template +class is_observer +{ + template + static typename C::observer_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_observer>::value; +}; + +struct tag_dynamic_observer {}; +template +class is_dynamic_observer +{ + struct not_void {}; + template + static typename C::dynamic_observer_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_dynamic_observer*>::value; +}; + struct tag_subscriber {}; template class is_subscriber @@ -28,6 +53,19 @@ public: static const bool value = std::is_convertible::type>(0)), tag_subscriber*>::value; }; +struct tag_dynamic_observable {}; +template +class is_dynamic_observable +{ + struct not_void {}; + template + static typename C::dynamic_observable_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_dynamic_observable*>::value; +}; + template class dynamic_observable; diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index 7e585a1..c504372 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -23,11 +23,11 @@ template class is_source { template - static typename C::source_tag check(int); + static typename C::source_tag* check(int); template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_source>::value; + static const bool value = std::is_convertible::type>(0)), tag_source*>::value; }; } diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index 82b05e7..bf4d1a8 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -202,8 +202,8 @@ public: return s.has_observers(); } - observer> get_observer() const { - return observer>(s); + subscriber>> get_subscriber(composite_subscription cs = composite_subscription()) const { + return make_subscriber(cs, observer>(s)); } observable get_observable() const { return make_dynamic_observable([this](subscriber o){ diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index efa84e8..364cd4e 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -74,12 +74,13 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ std::vector> f(n); #endif + auto o = sub.get_subscriber(); + for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC - f[i] = std::async([sub]() { + f[i] = std::async([sub, o]() { auto source = sub.get_observable(); - auto subscription = sub.get_observer(); - while(subscription.is_subscribed()) { + while(o.is_subscribed()) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); rx::composite_subscription cs; source.subscribe(cs, [cs](int){ @@ -92,8 +93,6 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ sub.get_observable().subscribe([c](int){++(*c);}); } - auto o = sub.get_observer(); - auto start = clock::now(); for (int i = 0; i < onnextcalls; i++) { o.on_next(i); @@ -114,10 +113,12 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ std::vector> f(n); #endif + auto o = sub.get_subscriber(); + for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC - f[i] = std::async([sub]() { - while(sub.get_observer().is_subscribed()) { + f[i] = std::async([sub, o]() { + while(o.is_subscribed()) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); rx::composite_subscription cs; sub.get_observable().subscribe(cs, [cs](int){ @@ -133,8 +134,6 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ .subscribe([c](int){++(*c);}); } - auto o = sub.get_observer(); - auto start = clock::now(); rxs::range(0, onnextcalls).subscribe(o); auto finish = clock::now(); @@ -180,13 +179,14 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ WHEN("multicasting an infinite source"){ + auto o = s.get_subscriber(); sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ s = rxsub::subject(); return rxsc::make_action_empty();}); - sc->schedule_absolute(200, [&xs, &s](rxsc::action, rxsc::scheduler){ - xs.subscribe(s.get_observer()); return rxsc::make_action_empty();}); - sc->schedule_absolute(1000, [&s](rxsc::action, rxsc::scheduler){ - s.get_observer().unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ + xs.subscribe(o); return rxsc::make_action_empty();}); + sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ + o.unsubscribe(); return rxsc::make_action_empty();}); sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); @@ -272,13 +272,14 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ WHEN("multicasting an infinite source"){ + auto o = s.get_subscriber(); sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ s = rxsub::subject(); return rxsc::make_action_empty();}); - sc->schedule_absolute(200, [&xs, &s](rxsc::action, rxsc::scheduler){ - xs.subscribe(s.get_observer()); return rxsc::make_action_empty();}); - sc->schedule_absolute(1000, [&s](rxsc::action, rxsc::scheduler){ - s.get_observer().unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ + xs.subscribe(o); return rxsc::make_action_empty();}); + sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ + o.unsubscribe(); return rxsc::make_action_empty();}); sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); @@ -368,12 +369,14 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ WHEN("multicasting an infinite source"){ + auto o = s.get_subscriber(); + sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ s = rxsub::subject(); return rxsc::make_action_empty();}); - sc->schedule_absolute(200, [&xs, &s](rxsc::action, rxsc::scheduler){ - xs.subscribe(s.get_observer()); return rxsc::make_action_empty();}); - sc->schedule_absolute(1000, [&s](rxsc::action, rxsc::scheduler){ - s.get_observer().unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ + xs.subscribe(o); return rxsc::make_action_empty();}); + sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ + o.unsubscribe(); return rxsc::make_action_empty();}); sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); -- GitLab From c1d02264d81b361aa131b3a6a9a4dc0b71b70ab8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Mar 2014 07:59:42 -0700 Subject: [PATCH 225/782] add variadic versions of make_... --- Rx/v2/src/rxcpp/rx-observer.hpp | 16 ++++ Rx/v2/src/rxcpp/rx-subscriber.hpp | 8 ++ Rx/v2/src/rxcpp/rx-util.hpp | 117 +++++++++++++++++++++++++++++- 3 files changed, 140 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index f3e5181..6f3650c 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -446,6 +446,13 @@ struct tag_observer_set } +#if RXCPP_USE_VARIADIC_TEMPLATES +template +auto make_observer(Arg0&& a0, ArgN&&... an) + -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...))) { + return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...)); +} +#else template auto make_observer(Arg0&& a0) -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0)))) { @@ -466,7 +473,15 @@ auto make_observer(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } +#endif +#if RXCPP_USE_VARIADIC_TEMPLATES +template +auto make_observer_dynamic(Arg0&& a0, ArgN&&... an) + -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...))) { + return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...)); +} +#else template auto make_observer_dynamic(Arg0&& a0) -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0)))) { @@ -487,6 +502,7 @@ auto make_observer_dynamic(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } +#endif } diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 7bca7ad..0fdbbce 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -262,6 +262,13 @@ struct tag_subscriber_set } +#if RXCPP_USE_VARIADIC_TEMPLATES +template +auto make_subscriber(Arg0&& a0, ArgN&&... an) + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(an)...))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(an)...)); +} +#else template auto make_subscriber(Arg0&& a0) -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0)))) { @@ -292,6 +299,7 @@ auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5 -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } +#endif } diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index fa6efe9..71d75c7 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -198,6 +198,69 @@ private: Function* function; }; +#if RXCPP_USE_VARIADIC_TEMPLATES + +namespace detail { + +template +struct select_arg +{ + template + static auto get(GArg&&, GArgN&&... gan) + -> decltype(select_arg::get(std::forward(gan)...)) { + return select_arg::get(std::forward(gan)...); + } +}; +template +struct select_arg +{ + template + static auto get(GArg&& ga, GArgN&&...) + -> decltype(std::forward(ga)) { + return std::forward(ga); + } +}; + +} + +template class Predicate, class Default, class... ArgN> +struct arg_resolver_n; + +template class Predicate, class Default, class Arg, class... ArgN> +struct arg_resolver_n +{ + static const int n = N; + static const bool is_arg = true; + typedef Arg result_type; + typedef arg_resolver_n this_type; + typedef arg_resolver_n next_type; + typedef typename std::conditional::value, this_type, typename next_type::type>::type type; + result_type value; + template + arg_resolver_n(CArgN&&... can) + : value(detail::select_arg::get(std::forward(can)...)) { + } +}; + +template class Predicate, class Default> +struct arg_resolver_n +{ + static const int n = -1; + static const bool is_arg = false; + typedef Default result_type; + typedef arg_resolver_n this_type; + typedef this_type type; + result_type value; + template + struct select_arg + { + }; + template + arg_resolver_n(CArgN&&...) + : value() { + } +}; +#else template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct arg_resolver_n; @@ -310,16 +373,32 @@ struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5 : value() { } }; +#endif +#if RXCPP_USE_VARIADIC_TEMPLATES +template class Predicate, class Default, class... ArgN> +struct arg_resolver +{ + typedef typename arg_resolver_n::type...>::type type; +}; +#else struct tag_unresolvable {}; template class Predicate, class Default, class Arg0 = tag_unresolvable, class Arg1 = tag_unresolvable, class Arg2 = tag_unresolvable, class Arg3 = tag_unresolvable, class Arg4 = tag_unresolvable, class Arg5 = tag_unresolvable> struct arg_resolver { typedef typename arg_resolver_n<5, Predicate, Default, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type>::type type; }; +#endif - +#if RXCPP_USE_VARIADIC_TEMPLATES +template class Predicate, class Default, + class... ArgN> +auto resolve_arg(ArgN&&... an) +-> decltype(typename arg_resolver::type(std::forward(an)...)) { + return typename arg_resolver::type(std::forward(an)...); +} +#else template class Predicate, class Default> auto resolve_arg() -> decltype(typename arg_resolver::type(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { @@ -377,6 +456,7 @@ auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a return typename arg_resolver::type( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)); } +#endif struct arg_resolver_term {}; @@ -404,6 +484,17 @@ template struct arg_resolver_set { typedef arg_resolver_set next_set; +#if RXCPP_USE_VARIADIC_TEMPLATES + template + auto operator()(ArgN&&... an) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(an)...)), + next_set()(std::forward(an)...))) { + return std::tuple_cat( + std::make_tuple(resolve_arg(std::forward(an)...)), + next_set()(std::forward(an)...)); + } +#else inline auto operator()() -> decltype(std::tuple_cat( std::make_tuple(resolve_arg()), @@ -466,8 +557,15 @@ struct arg_resolver_set std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } +#endif }; +#if RXCPP_USE_VARIADIC_TEMPLATES +template +inline std::tuple<> resolve_arg_set(arg_resolver_term&&, ArgN&&... ) { + return std::tuple<>(); +} +#else inline std::tuple<> resolve_arg_set(arg_resolver_term&&) { return std::tuple<>(); } @@ -501,7 +599,23 @@ template inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& , Arg4&& , Arg5&& ) { return std::tuple<>(); } +#endif +#if RXCPP_USE_VARIADIC_TEMPLATES +template +auto resolve_arg_set(Tag&&, ArgN&&... an) + -> decltype(std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(an)...)), + resolve_arg_set(typename Tag::next_tag(), + std::forward(an)...))) { + return std::tuple_cat( + std::make_tuple(resolve_arg( + std::forward(an)...)), + resolve_arg_set(typename Tag::next_tag(), + std::forward(an)...)); +} +#else template auto resolve_arg_set(Tag&&) -> decltype(std::tuple_cat( @@ -589,6 +703,7 @@ auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a resolve_arg_set(typename Tag::next_tag(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } +#endif } -- GitLab From babf204eebab2a9a3ed525e6a68d8af212fa4cb0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Mar 2014 08:26:14 -0700 Subject: [PATCH 226/782] remove subscription from observer --- Rx/v2/src/rxcpp/rx-observer.hpp | 166 ++++--------------------- Rx/v2/src/rxcpp/rx-subscriber.hpp | 37 +++--- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 57 ++++----- Rx/v2/test/subjects/subject.cpp | 24 ++-- Rx/v2/test/subscriptions/observer.cpp | 40 +----- 5 files changed, 79 insertions(+), 245 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 6f3650c..0aee374 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -11,61 +11,11 @@ namespace rxcpp { template -struct observer_root : public subscription_base +struct observer_base { typedef T value_type; - typedef composite_subscription subscription_type; - typedef typename subscription_type::weak_subscription weak_subscription; typedef tag_observer observer_tag; }; -template -struct observer_base : public observer_root -{ -private: - typedef observer_base this_type; - - mutable typename this_type::subscription_type s; - -public: - observer_base() - { - } - observer_base(typename this_type::subscription_type s) - : s(std::move(s)) - { - } - observer_base(const observer_base& o) - : s(o.s) - { - } - observer_base(observer_base&& o) - : s(std::move(o.s)) - { - } - observer_base& operator=(observer_base o) { - swap(o); - return *this; - } - void swap(observer_base& o) { - using std::swap; - swap(s, o.s); - } - const typename this_type::subscription_type& get_subscription() const { - return s; - } - bool is_subscribed() const { - return s.is_subscribed(); - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - return s.add(std::move(ds)); - } - void remove(typename this_type::weak_subscription ws) const { - s.remove(ws); - } - void unsubscribe() const { - s.unsubscribe(); - } -}; namespace detail { template @@ -143,9 +93,8 @@ public: } template - dynamic_observer(composite_subscription cs, OnNext&& n, OnError&& e, OnCompleted&& c) - : base_type(std::move(cs)) - , onnext(std::forward(n)) + dynamic_observer(OnNext&& n, OnError&& e, OnCompleted&& c) + : onnext(std::forward(n)) , onerror(std::forward(e)) , oncompleted(std::forward(c)) { @@ -163,7 +112,6 @@ public: } void swap(dynamic_observer& o) { using std::swap; - observer_base::swap(o); swap(onnext, o.onnext); swap(onerror, o.onerror); swap(oncompleted, o.oncompleted); @@ -205,23 +153,20 @@ public: static_assert(detail::is_on_error::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); static_assert(detail::is_on_completed::value, "Function supplied for on_completed must be a function with the signature void();"); - explicit static_observer(composite_subscription cs, on_next_t n, on_error_t e, on_completed_t c) - : observer_base(std::move(cs)) - , onnext(std::move(n)) + explicit static_observer(on_next_t n, on_error_t e, on_completed_t c) + : onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) { } static_observer(const this_type& o) - : observer_base(o) - , onnext(o.onnext) + : onnext(o.onnext) , onerror(o.onerror) , oncompleted(o.oncompleted) { } static_observer(this_type&& o) - : observer_base(std::move(o)) - , onnext(std::move(o.onnext)) + : onnext(std::move(o.onnext)) , onerror(std::move(o.onerror)) , oncompleted(std::move(o.oncompleted)) { @@ -232,7 +177,6 @@ public: } void swap(this_type& o) { using std::swap; - observer_base::swap(o); swap(onnext, o.onnext); swap(onerror, o.onerror); swap(oncompleted, o.oncompleted); @@ -250,26 +194,11 @@ public: }; template -class observer : public observer_root +class observer : public observer_base { typedef observer this_type; typedef typename std::conditional::value, typename std::decay::type, dynamic_observer>::type inner_t; - struct detacher - { - ~detacher() - { - if (that) { - that->unsubscribe(); - } - } - detacher(const observer* that) - : that(that) - { - } - const observer* that; - }; - inner_t inner; public: ~observer() @@ -283,42 +212,17 @@ public: { } void on_next(T t) const { - if (is_subscribed()) { - detacher protect(this); - inner.on_next(std::move(t)); - protect.that = nullptr; - } + inner.on_next(std::move(t)); } void on_error(std::exception_ptr e) const { - if (is_subscribed()) { - detacher protect(this); - inner.on_error(e); - } + inner.on_error(e); } void on_completed() const { - if (is_subscribed()) { - detacher protect(this); - inner.on_completed(); - } - } - const typename this_type::subscription_type& get_subscription() const { - return inner.get_subscription(); - } - bool is_subscribed() const { - return inner.is_subscribed(); - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - return inner.add(std::move(ds)); - } - void remove(typename this_type::weak_subscription ws) const { - inner.remove(ws); - } - void unsubscribe() const { - inner.unsubscribe(); + inner.on_completed(); } }; template -class observer : public observer_root +class observer : public observer_base { typedef observer this_type; public: @@ -331,22 +235,6 @@ public: } void on_completed() const { } - const typename this_type::subscription_type& get_subscription() const { - static typename this_type::subscription_type result; - result.unsubscribe(); - return result; - } - bool is_subscribed() const { - return false; - } - typename this_type::weak_subscription add(dynamic_subscription ds) const { - ds.unsubscribe(); - return typename this_type::weak_subscription(); - } - void remove(typename this_type::weak_subscription) const { - } - void unsubscribe() const { - } }; template @@ -359,8 +247,8 @@ namespace detail { template auto make_observer_resolved(ResolvedArgSet&& rs) - -> observer(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>> { - return make_observer_resolved(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>>(std::forward(rs)); + -> observer(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>> { + return make_observer_resolved(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>>(std::forward(rs)); } template auto make_observer_dynamic_resolved(ResolvedArgSet&& rs) @@ -373,14 +261,13 @@ auto make_observer_resolved(ResolvedArgSet&& rs) -> observer { typedef I inner_type; return observer(inner_type( - std::get<0>(std::forward(rs)).value, + std::move(std::get<0>(std::forward(rs)).value), std::move(std::get<1>(std::forward(rs)).value), - std::move(std::get<2>(std::forward(rs)).value), - std::move(std::get<3>(std::forward(rs)).value))); + std::move(std::get<2>(std::forward(rs)).value))); - typedef typename std::decay(std::forward(rs)))>::type rn_t; - typedef typename std::decay(std::forward(rs)))>::type re_t; - typedef typename std::decay(std::forward(rs)))>::type rc_t; + typedef typename std::decay(std::forward(rs)))>::type rn_t; + typedef typename std::decay(std::forward(rs)))>::type re_t; + typedef typename std::decay(std::forward(rs)))>::type rc_t; static_assert(rn_t::is_arg, "onnext is a required parameter"); static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); @@ -388,16 +275,6 @@ auto make_observer_resolved(ResolvedArgSet&& rs) static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); } -struct tag_subscription_resolution -{ - template - struct predicate - { - static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; - }; - typedef composite_subscription default_type; -}; - template struct tag_onnext_resolution { @@ -436,10 +313,9 @@ struct tag_oncompleted_resolution template struct tag_observer_set - : public rxu::detail::tag_set, + : public rxu::detail::tag_set, rxu::detail::tag_set>>> + rxu::detail::tag_set>> { }; diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 0fdbbce..72c9133 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -10,7 +10,7 @@ namespace rxcpp { template -struct subscriber_base : public observer_root, public subscription_base, public resumption_base +struct subscriber_base : public observer_base, public subscription_base, public resumption_base { typedef tag_subscriber subscriber_tag; }; @@ -148,9 +148,6 @@ struct observer_selector template static auto get_observer(Set&& rs) -> decltype(make_observer_resolved(std::forward(rs))) { - if (!std::get<0>(std::forward(rs)).value.is_subscribed()) { - abort(); - } return make_observer_resolved(std::forward(rs)); } }; @@ -166,16 +163,13 @@ struct observer_selector template auto select_observer(ResolvedArgSet&& rs) - -> decltype(observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs))) { - if (!std::get<0>(std::forward(rs)).value.is_subscribed()) { - abort(); - } - return observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs)); + -> decltype(observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs))) { + return observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs)); typedef typename std::decay(std::forward(rs)))>::type rr_t; - typedef typename std::decay(std::forward(rs)))>::type rn_t; - typedef typename std::decay(std::forward(rs)))>::type re_t; - typedef typename std::decay(std::forward(rs)))>::type rc_t; + typedef typename std::decay(std::forward(rs)))>::type rn_t; + typedef typename std::decay(std::forward(rs)))>::type re_t; + typedef typename std::decay(std::forward(rs)))>::type rc_t; typedef typename std::decay(std::forward(rs)))>::type ro_t; typedef typename std::decay(std::forward(rs)))>::type rs_t; @@ -187,10 +181,7 @@ template auto make_subscriber_resolved(ResolvedArgSet&& rsArg) -> subscriber(std::move(rsArg)))> { const auto rs = std::forward(rsArg); - if (!std::get<0>(rs).value.is_subscribed()) { - abort(); - } - const auto rsub = std::get<0>(rs); + const auto rsub = std::get<3>(rs); const auto rr = std::get<4>(rs); const auto rscrbr = std::get<6>(rs); const auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : rr.value; @@ -207,6 +198,16 @@ auto make_subscriber_resolved(ResolvedArgSet&& rsArg) #endif } +struct tag_subscription_resolution +{ + template + struct predicate + { + static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; + }; + typedef composite_subscription default_type; +}; + template struct tag_subscriber_resolution { @@ -250,10 +251,10 @@ struct tag_resumption_resolution template struct tag_subscriber_set // the first four must be the same as tag_observer_set or the indexing will fail - : public rxu::detail::tag_set, + : public rxu::detail::tag_set, rxu::detail::tag_set, rxu::detail::tag_set>>>>>>> diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index cd3b7ff..60dcff9 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -164,9 +164,6 @@ public: return make_cold_observable(rxu::to_vector(arr)); } - template - rxt::testable_observer make_observer(); - template subscriber> make_subscriber(); }; @@ -216,40 +213,32 @@ public: }; template -rxt::testable_observer test::make_observer() +subscriber> test::make_subscriber() { typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - - std::shared_ptr> ts(new mock_observer( - std::static_pointer_cast(shared_from_this()))); - - return rxt::testable_observer(ts, make_observer_dynamic( - // on_next - [ts](T value) - { - ts->m.push_back( - recorded_type(ts->sc->clock(), notification_type::on_next(value))); - }, - // on_error - [ts](std::exception_ptr e) - { - ts->m.push_back( - recorded_type(ts->sc->clock(), notification_type::on_error(e))); - }, - // on_completed - [ts]() - { - ts->m.push_back( - recorded_type(ts->sc->clock(), notification_type::on_completed())); - })); -} - -template -subscriber> test::make_subscriber() -{ - auto to = this->make_observer(); - return rxcpp::make_subscriber(to.get_subscription(), to); + + std::shared_ptr> ts(new mock_observer(std::static_pointer_cast(shared_from_this()))); + + return rxcpp::make_subscriber(rxt::testable_observer(ts, make_observer_dynamic( + // on_next + [ts](T value) + { + ts->m.push_back( + recorded_type(ts->sc->clock(), notification_type::on_next(value))); + }, + // on_error + [ts](std::exception_ptr e) + { + ts->m.push_back( + recorded_type(ts->sc->clock(), notification_type::on_error(e))); + }, + // on_completed + [ts]() + { + ts->m.push_back( + recorded_type(ts->sc->clock(), notification_type::on_completed())); + }))); } template diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 364cd4e..353c6dc 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -264,11 +264,11 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ rxsub::subject s; - auto results1 = sc->make_observer(); + auto results1 = sc->make_subscriber(); - auto results2 = sc->make_observer(); + auto results2 = sc->make_subscriber(); - auto results3 = sc->make_observer(); + auto results3 = sc->make_subscriber(); WHEN("multicasting an infinite source"){ @@ -306,7 +306,7 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ m::on_next(520, 7) }; auto required = rxu::to_vector(items); - auto actual = results1.messages(); + auto actual = results1.get_observer().messages(); REQUIRE(required == actual); } @@ -317,7 +317,7 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ m::on_completed(630) }; auto required = rxu::to_vector(items); - auto actual = results2.messages(); + auto actual = results2.get_observer().messages(); REQUIRE(required == actual); } @@ -326,7 +326,7 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ m::on_completed(900) }; auto required = rxu::to_vector(items); - auto actual = results3.messages(); + auto actual = results3.get_observer().messages(); REQUIRE(required == actual); } @@ -360,11 +360,11 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ rxsub::subject s; - auto results1 = sc->make_observer(); + auto results1 = sc->make_subscriber(); - auto results2 = sc->make_observer(); + auto results2 = sc->make_subscriber(); - auto results3 = sc->make_observer(); + auto results3 = sc->make_subscriber(); WHEN("multicasting an infinite source"){ @@ -403,7 +403,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ m::on_next(520, 7) }; auto required = rxu::to_vector(items); - auto actual = results1.messages(); + auto actual = results1.get_observer().messages(); REQUIRE(required == actual); } @@ -414,7 +414,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ m::on_error(630, ex) }; auto required = rxu::to_vector(items); - auto actual = results2.messages(); + auto actual = results2.get_observer().messages(); REQUIRE(required == actual); } @@ -423,7 +423,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ m::on_error(900, ex) }; auto required = rxu::to_vector(items); - auto actual = results3.messages(); + auto actual = results3.get_observer().messages(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 42caf7b..34ce458 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -127,15 +127,14 @@ SCENARIO("observers with subscription traits", "[observer][subscription][traits] } } -SCENARIO("observer behavior", "[observer][traits]"){ - GIVEN("given some observer types"){ +SCENARIO("subscriber behavior", "[observer][traits]"){ + GIVEN("given some subscriber types"){ int result = 0; auto next = [&result](int i){result += i;}; auto error = [&result](std::exception_ptr){result += 10;}; auto completed = [&result](){result += 100;}; - auto dob = rx::make_observer_dynamic(next, error, completed); - auto so = rx::make_observer(next, error, completed); - auto eo = rx::make_observer(); + auto dob = rx::make_subscriber(rx::make_observer_dynamic(next, error, completed)); + auto so = rx::make_subscriber(next, error, completed); WHEN("nothing is called"){ THEN("dynamic_observer result is 0"){ REQUIRE(result == 0); @@ -152,9 +151,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ THEN("static_observer is subscribed"){ REQUIRE(so.is_subscribed()); } - THEN("observer is subscribed"){ - REQUIRE(!eo.is_subscribed()); - } } WHEN("onnext is called with 1"){ THEN("dynamic_observer result is 1"){ @@ -165,10 +161,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ so.on_next(1); REQUIRE(result == 1); } - THEN("observer result is 0"){ - eo.on_next(1); - REQUIRE(result == 0); - } THEN("dynamic_observer is subscribed"){ dob.on_next(1); REQUIRE(dob.is_subscribed()); @@ -177,10 +169,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ so.on_next(1); REQUIRE(so.is_subscribed()); } - THEN("observer is not subscribed"){ - eo.on_next(1); - REQUIRE(!eo.is_subscribed()); - } } WHEN("onnext is called with 1 after error"){ THEN("dynamic_observer result is 10"){ @@ -193,11 +181,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ so.on_next(1); REQUIRE(result == 10); } - THEN("observer result is 0"){ - eo.on_error(std::current_exception()); - eo.on_next(1); - REQUIRE(result == 0); - } THEN("dynamic_observer is not subscribed"){ dob.on_error(std::current_exception()); dob.on_next(1); @@ -208,11 +191,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ so.on_next(1); REQUIRE(!so.is_subscribed()); } - THEN("observer is not subscribed"){ - eo.on_error(std::current_exception()); - eo.on_next(1); - REQUIRE(!eo.is_subscribed()); - } } WHEN("onnext is called with 1 after completed"){ THEN("dynamic_observer result is 100"){ @@ -225,11 +203,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ so.on_next(1); REQUIRE(result == 100); } - THEN("observer result is 0"){ - eo.on_completed(); - eo.on_next(1); - REQUIRE(result == 0); - } THEN("dynamic_observer is not subscribed"){ dob.on_completed(); dob.on_next(1); @@ -240,11 +213,6 @@ SCENARIO("observer behavior", "[observer][traits]"){ so.on_next(1); REQUIRE(!so.is_subscribed()); } - THEN("observer is not subscribed"){ - eo.on_completed(); - eo.on_next(1); - REQUIRE(!eo.is_subscribed()); - } } } } -- GitLab From 550cfb42b2e524c0b438634b805d7924b0156025 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Mar 2014 15:52:38 -0700 Subject: [PATCH 227/782] test fixes --- Rx/v2/test/subjects/subject.cpp | 13 ++++++------- Rx/v2/test/subscriptions/observer.cpp | 20 -------------------- 2 files changed, 6 insertions(+), 27 deletions(-) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 353c6dc..620863a 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -181,8 +181,8 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ - s = rxsub::subject(); return rxsc::make_action_empty();}); + sc->schedule_absolute(100, [&s, &o](rxsc::action, rxsc::scheduler){ + s = rxsub::subject(); o = s.get_subscriber(); return rxsc::make_action_empty();}); sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ xs.subscribe(o); return rxsc::make_action_empty();}); sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ @@ -274,8 +274,8 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ - s = rxsub::subject(); return rxsc::make_action_empty();}); + sc->schedule_absolute(100, [&s, &o](rxsc::action, rxsc::scheduler){ + s = rxsub::subject(); o = s.get_subscriber(); return rxsc::make_action_empty();}); sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ xs.subscribe(o); return rxsc::make_action_empty();}); sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ @@ -368,11 +368,10 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ WHEN("multicasting an infinite source"){ - auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s](rxsc::action, rxsc::scheduler){ - s = rxsub::subject(); return rxsc::make_action_empty();}); + sc->schedule_absolute(100, [&s, &o](rxsc::action, rxsc::scheduler){ + s = rxsub::subject(); o = s.get_subscriber(); return rxsc::make_action_empty();}); sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ xs.subscribe(o); return rxsc::make_action_empty();}); sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 34ce458..1bed6b6 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -107,26 +107,6 @@ SCENARIO("non-observer traits", "[observer][traits]"){ } } -SCENARIO("observers with subscription traits", "[observer][subscription][traits]"){ - GIVEN("given some observer types"){ - auto emptyNext = [](int){}; - auto dob = rx::make_observer_dynamic(emptyNext); - auto so = rx::make_observer(emptyNext); - auto eo = rx::make_observer(); - WHEN("tested"){ - THEN("is_subscription value is true for dynamic_observer"){ - REQUIRE(rx::is_subscription::value); - } - THEN("is_subscription value is true for static_observer"){ - REQUIRE(rx::is_subscription::value); - } - THEN("is_subscription value is true for observer"){ - REQUIRE(rx::is_subscription::value); - } - } - } -} - SCENARIO("subscriber behavior", "[observer][traits]"){ GIVEN("given some subscriber types"){ int result = 0; -- GitLab From 9939674948d96ce1d1492fcb442c23e64c3a4de5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 20 Mar 2014 16:00:34 -0700 Subject: [PATCH 228/782] add support for operator | and well as operator >> --- Rx/v2/src/rxcpp/rx-observable.hpp | 14 ++++++++++++++ Rx/v2/src/rxcpp/rx-test.hpp | 14 ++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index ced294b..5c646ca 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -305,10 +305,24 @@ public: } +// +// support range() >> filter() >> subscribe() syntax +// '>>' is spelled 'stream' +// template auto operator >> (const rxcpp::observable& source, OperatorFactory&& of) -> decltype(source.op(std::forward(of))) { return source.op(std::forward(of)); } +// +// support range() | filter() | subscribe() syntax +// '|' is spelled 'pipe' +// +template +auto operator | (const rxcpp::observable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); +} + #endif diff --git a/Rx/v2/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp index e519cf8..4038eb7 100644 --- a/Rx/v2/src/rxcpp/rx-test.hpp +++ b/Rx/v2/src/rxcpp/rx-test.hpp @@ -121,12 +121,26 @@ namespace rxt=test; } +// +// support range() >> filter() >> subscribe() syntax +// '>>' is spelled 'stream' +// template auto operator >> (const rxcpp::test::testable_observable& source, OperatorFactory&& of) -> decltype(source.op(std::forward(of))) { return source.op(std::forward(of)); } +// +// support range() | filter() | subscribe() syntax +// '|' is spelled 'pipe' +// +template +auto operator | (const rxcpp::test::testable_observable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); +} + #include "schedulers/rx-test.hpp" #endif -- GitLab From 7bf5176350f3b8d34d9af255dd74b651c3bf3c6a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 22 Mar 2014 12:20:40 -0700 Subject: [PATCH 229/782] start switch to schedulable --- Rx/v2/src/rxcpp/rx-predef.hpp | 40 ++ Rx/v2/src/rxcpp/rx-scheduler.hpp | 589 ++++++++++++++++++++++++---- Rx/v2/src/rxcpp/rx-subscriber.hpp | 59 ++- Rx/v2/src/rxcpp/rx-subscription.hpp | 47 +++ 4 files changed, 629 insertions(+), 106 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 5779f79..18c356d 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -9,6 +9,46 @@ namespace rxcpp { +struct tag_action {}; +template +class is_action +{ + struct not_void {}; + template + static typename C::action_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_action*>::value; +}; + +struct tag_scheduler {}; +template +class is_scheduler +{ + struct not_void {}; + template + static typename C::scheduler_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_scheduler*>::value; +}; + +struct tag_schedulable {}; +template +class is_schedulable +{ + struct not_void {}; + template + static typename C::schedulable_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_schedulable*>::value; +}; + + template class dynamic_observer; diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 7ebc2cb..98f2f9e 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -11,139 +11,582 @@ namespace rxcpp { namespace schedulers { +namespace detail { + class action_type; -typedef std::shared_ptr action; +typedef std::shared_ptr action_ptr; -class scheduler_base; -typedef std::shared_ptr scheduler; +class scheduler_interface; +typedef std::shared_ptr scheduler_interface_ptr; -class action_type - : public subscription_base - , public std::enable_shared_from_this +} + +struct action_base { - typedef action_type this_type; + typedef tag_action action_tag; +}; + +struct scheduler_base +{ + typedef tag_scheduler scheduler_tag; +}; + +class scheduler_interface + : public std::enable_shared_from_this +{ + typedef scheduler_interface this_type; public: - typedef composite_subscription subscription_type; - typedef subscription_type::weak_subscription weak_subscription; - typedef std::function function_type; + typedef std::chrono::steady_clock clock_type; -private: - mutable this_type::subscription_type s; - function_type f; + virtual ~scheduler_interface() {} + + virtual clock_type::time_point now() const = 0; + + virtual bool is_tail_recursion_allowed() const = 0; + + virtual void schedule(composite_subscription cs, action a) const = 0; + virtual void schedule(clock_type::duration when, composite_subscription cs, action a) const = 0; + virtual void schedule(clock_type::time_point when, composite_subscription cs, action a) const = 0; +}; + + +struct schedulable_base : public subscription_base, public scheduler_base, public action_base +{ + typedef tag_schedulable schedulable_tag; +}; + +class schedulable; - static action shared_empty; +namespace action_duration { + enum type { + invalid, + runs_short, + runs_long + }; +} +class action : public action_base +{ + typedef action this_type; + detail::action_ptr inner; + static detail::action_ptr shared_empty; + friend bool operator==(const action&, const action&); public: - action_type() + action() + { + } + explicit action(detail::action_ptr i) + : inner(std::move(i)) { - s.unsubscribe(); } - explicit action_type(function_type f) - : f(std::move(f)) + inline static action empty() { + return action(shared_empty); + } + + inline action_duration::type get_duration() const { + return inner->get_duration(); + } + + inline void operator()(const schedulable& s) const; +}; + +//static +RXCPP_SELECT_ANY detail::action_ptr action::shared_empty = std::make_shared(); + +inline bool operator==(const action& lhs, const action& rhs) { + return lhs.inner == rhs.inner; +} +inline bool operator!=(const action& lhs, const action& rhs) { + return !(lhs == rhs); +} + +class scheduler : public scheduler_base +{ + typedef scheduler this_type; + detail::scheduler_interface_ptr inner; + friend bool operator==(const scheduler&, const scheduler&); +public: + typedef std::chrono::steady_clock clock_type; + + scheduler() { - if (!this->f) { - s.unsubscribe(); - } } - action_type(this_type::subscription_type s, function_type f) - : s(std::move(s)) - , f(std::move(f)) + explicit scheduler(detail::scheduler_interface_ptr i) + : inner(std::move(i)) { - if (!this->f) { - this->s.unsubscribe(); - } } - inline static action empty() { - return shared_empty; + inline clock_type::time_point now() const { + return inner->now(); } - inline action operator()(scheduler sc) { - if (is_subscribed() && f) { - return f(this->shared_from_this(), std::move(sc)); + inline bool is_tail_recursion_allowed() const { + return inner->is_tail_recursion_allowed(); + } + + inline void schedule(composite_subscription cs, action a) const { + inner->schedule(std::move(cs), std::move(a)); + } + inline void schedule(clock_type::duration when, composite_subscription cs, action a) const { + inner->schedule(when, std::move(cs), std::move(a)); + } + inline void schedule(clock_type::time_point when, composite_subscription cs, action a) const { + inner->schedule(when, std::move(cs), std::move(a)); + } +}; + +inline bool operator==(const scheduler& lhs, const scheduler& rhs) { + return lhs.inner == rhs.inner; +} +inline bool operator!=(const scheduler& lhs, const scheduler& rhs) { + return !(lhs == rhs); +} + +class schedulable : public schedulable_base +{ + typedef schedulable this_type; + + composite_subscription lifetime; + scheduler controller; + action activity; + + struct detacher + { + ~detacher() + { + if (that) { + that->unsubscribe(); + } + } + detacher(const this_type* that) + : that(that) + { } - return empty(); + const this_type* that; + }; + +public: + typedef typename composite_subscription::weak_subscription weak_subscription; + typedef typename composite_subscription::shared_subscription shared_subscription; + typedef std::chrono::steady_clock clock_type; + + schedulable() + { + } + schedulable(composite_subscription cs, scheduler q, action a) + : lifetime(std::move(cs)) + , controller(std::move(q)) + , activity(std::move(a)) + { } + inline const composite_subscription& get_subscription() const { + return lifetime; + } + inline composite_subscription& get_subscription() { + return lifetime; + } + inline const scheduler& get_scheduler() const { + return controller; + } + inline scheduler& get_scheduler() { + return controller; + } + inline const action& get_action() const { + return activity; + } + inline action& get_action() { + return activity; + } + + inline static schedulable empty() { + return schedulable(composite_subscription::empty(), controller, action::empty()); + } + + // composite_subscription + // inline bool is_subscribed() const { - return s.is_subscribed(); + return lifetime.is_subscribed(); } - inline this_type::weak_subscription add(dynamic_subscription ds) const { - return s.add(std::move(ds)); + inline weak_subscription add(shared_subscription s) const { + return lifetime.add(std::move(s)); } - inline void remove(this_type::weak_subscription ws) const { - s.remove(ws); + inline weak_subscription add(dynamic_subscription s) const { + return lifetime.add(std::move(s)); + } + inline void remove(weak_subscription w) const { + return lifetime.remove(std::move(w)); + } + inline void clear() const { + return lifetime.clear(); } inline void unsubscribe() const { - s.unsubscribe(); + return lifetime.unsubscribe(); + } + + // scheduler + // + inline clock_type::time_point now() const { + return controller.now(); + } + inline bool is_tail_recursion_allowed() const { + return controller.is_tail_recursion_allowed(); + } + inline void schedule() const { + controller.schedule(lifetime, activity); + } + inline void schedule(clock_type::duration when) const { + controller.schedule(when, lifetime, activity); + } + inline void schedule(clock_type::time_point when) const { + controller.schedule(when, lifetime, activity); + } + + // action + // + inline action_duration::type get_duration() const { + return activity.get_duration(); + } + inline void operator()() const { + if (!is_subscribed()) { + abort(); + } + detacher protect(this); + activity(*this); + protect.that = nullptr; } }; -//static -RXCPP_SELECT_ANY action action_type::shared_empty = std::make_shared(); +inline bool operator==(const schedulable& lhs, const schedulable& rhs) { + return lhs.get_action() == rhs.get_action() && + lhs.get_scheduler() == rhs.get_scheduler() && + lhs.get_subscription() == rhs.get_subscription(); +} +inline bool operator!=(const schedulable& lhs, const schedulable& rhs) { + return !(lhs == rhs); +} + + +inline void action::operator()(const schedulable& s) const { + auto next = (*inner)(s); + if (next.is_subscribed()) { + next.schedule(); + } +} + + +namespace detail { + +class action_type + : public std::enable_shared_from_this +{ + typedef action_type this_type; + +public: + typedef std::function function_type; + +private: + action_duration::type d; + function_type f; + +public: + action_type() + { + } + + action_type(action_duration::type d, function_type f) + : d(d) + , f(std::move(f)) + { + } + + inline action_duration::type get_duration() const { + return d; + } + + inline schedulable operator()(const schedulable& s) { + if (f) { + return f(s); + } + return schedulable::empty(); + } +}; + +} inline action make_action_empty() { return action_type::empty(); } -inline action make_action(action_type::function_type f) { - return std::make_shared(std::move(f)); +template +inline action make_action(F&& f, action_duration::type d = action_duration::runs_short) { + auto fn = std::forward(f); + return action(std::make_shared( + d, + // tail-recurse inside of the virtual function call + // until a new action, lifetime or scheduler is returned + [fn](const schedulable& s) { + auto next = s; + auto last = s; + while (next.is_subscribed() && last == next && next.get_scheduler().is_tail_recursion_allowed()) { + last = next; + next = fn(next); + } + return next; + })); } -inline action make_action(action_type::subscription_type s, action_type::function_type f) { - return std::make_shared(std::move(s), std::move(f)); +template +inline scheduler make_scheduler() { + return scheduler(std::static_pointer_cast(std::make_shared())); } -class scheduler_base - : public std::enable_shared_from_this +namespace detail { + +template +struct is_action_function { - typedef scheduler_base this_type; + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)(*(schedulable*)nullptr)); + template + static not_void check(...); -public: - typedef std::chrono::steady_clock clock_type; + static const bool value = std::is_same::type>(0)), schedulable>::value; +}; - virtual ~scheduler_base() {} +struct tag_action_function_resolution +{ + template + struct predicate + { + static const bool value = is_action_function::value; + }; + typedef detail::action_type::function_type default_type; +}; - virtual clock_type::time_point now() = 0; +struct tag_action_duration_resolution +{ + template + struct predicate + { + static const bool value = std::is_same::type, action_duration::type>::value; + }; + struct default_type { + inline operator action_duration::type() { + return action_duration::runs_short; + } + }; +}; - virtual void schedule(action a) = 0; - virtual void schedule(clock_type::duration when, action a) = 0; - virtual void schedule(clock_type::time_point when, action a) = 0; +struct tag_when_resolution +{ + typedef scheduler_interface::clock_type clock_type; + typedef clock_type::duration duration_type; + typedef clock_type::duration time_point_type; + template + struct predicate + { + typedef typename std::decay::type decayedlhs; + static const bool value = std::is_same::value || + std::is_same::value; + }; + struct default_type { + inline operator time_point_type() { + return clock_type::now(); + } + }; +}; - inline void schedule(action_type::function_type f){ - return schedule(make_action(std::move(f))); - } - inline void schedule(clock_type::duration when, action_type::function_type f){ - return schedule(when, make_action(std::move(f))); - } - inline void schedule(clock_type::time_point when, action_type::function_type f){ - return schedule(when, make_action(std::move(f))); - } - inline void schedule(action_type::subscription_type s, action_type::function_type f){ - return schedule(make_action(std::move(s), std::move(f))); +struct tag_schedulable_resolution +{ + template + struct predicate : public is_schedulable + { + }; + typedef schedulable default_type; +}; + +struct tag_action_resolution +{ + template + struct predicate + { + static const bool value = !is_schedulable::value && is_action::value; + }; + typedef action default_type; +}; + +struct tag_scheduler_resolution +{ + template + struct predicate + { + static const bool value = !is_schedulable::value && is_scheduler::value; + }; + typedef scheduler default_type; +}; + + +template +struct tag_schedulable_set + // the first four must be the same as tag_observer_set or the indexing will fail + : public rxu::detail::tag_set, + rxu::detail::tag_set, + rxu::detail::tag_set>>>>>> +{ +}; + +template +struct action_selector; + +template +struct action_selector +{ + template + static action get_action(Set& rs) { + return std::get<4>(rs).value; } - inline void schedule(clock_type::duration when, action_type::subscription_type s, action_type::function_type f){ - return schedule(when, make_action(std::move(s), std::move(f))); +}; +template +struct action_selector +{ + template + static action get_action(Set& rs) { + return make_action(std::move(std::get<5>(rs).value), std::get<6>(rs).value); } - inline void schedule(clock_type::time_point when, action_type::subscription_type s, action_type::function_type f){ - return schedule(when, make_action(std::move(s), std::move(f))); +}; +template<> +struct action_selector +{ + template + static action get_action(Set& rs) { + return std::get<1>(rs).value.get_action(); } }; +template +action select_action(ResolvedArgSet& rs) + -> decltype(action_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs)) { + return action_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs); + + typedef typename std::decay(std::forward(rs)))>::type rsc_t; + typedef typename std::decay(std::forward(rs)))>::type raf_t; + typedef typename std::decay(std::forward(rs)))>::type rad_t; + typedef typename std::decay(std::forward(rs)))>::type ra_t; + typedef typename std::decay(std::forward(rs)))>::type rscbl_t; + + static_assert(rscbl_t::is_arg || ra_t::is_arg || raf_t::is_arg, "at least one of; action_function, action or schedulable is required"); + static_assert(int(ra_t::is_arg) + int(raf_t::is_arg) < 2, "action_function not allowed with an action"); + static_assert(int(ra_t::is_arg) + int(rad_t::is_arg) < 2, "action_duration not allowed with an action"); +} + +template +schedulable make_schedulable_resolved(ResolvedArgSet&& rsArg) { + const auto rs = std::forward(rsArg); + const auto rsub = std::get<2>(rs); + const auto rsc = std::get<3>(rs); + const auto rscbl = std::get<1>(rs); + const auto sc = (rscbl.is_arg && !rsc.is_arg) ? rscrbr.value.get_scheduler() : rsc.value; + const auto sub = (rscbl.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : rsub.value; + return schedulable(sub, sc, select_action(rs)); + + typedef typename std::decay(std::forward(rs)))>::type rw_t; + typedef typename std::decay(std::forward(rs)))>::type rsc_t; + typedef typename std::decay(std::forward(rs)))>::type rscbl_t; + + static_assert(when_invalid || !rw_t::is_arg, "when is an invalid parameter"); + static_assert(rscbl_t::is_arg || rsc_t::is_arg, "at least one of; scheduler or schedulable is required"); +} + +template +schedulable schedule_resolved(ResolvedArgSet&& rsArg) { + schedulable result = make_schedulable_resolved(std::forward(rsArg)); + const auto rw = std::get<0>(rs); + if (rx.is_arg) { + result.schedule(rw.value); + } else { + result.schedule(); + } + return result; +} + +} + +#if RXCPP_USE_VARIADIC_TEMPLATES +template +schedulable make_schedulable(Arg0&& a0, ArgN&&... an) { + return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); +} +#else +template +schedulable make_schedulable(Arg0&& a0) { + return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0))); +} +template +schedulable make_schedulable(Arg0&& a0, Arg1&& a1) { + return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1))); +} +template +schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2) { + return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2))); +} +template +schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) { + return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); +} +template +schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) { + return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); +} +#endif + +#if RXCPP_USE_VARIADIC_TEMPLATES +template +schedulable schedule(Arg0&& a0, ArgN&&... an) { + detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); +} +#else +template +schedulable schedule(Arg0&& a0) { + detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0))); +} +template +schedulable schedule(Arg0&& a0, Arg1&& a1) { + detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1))); +} +template +schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2) { + detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2))); +} +template +schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) { + detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); +} +template +schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) { + detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); +} +#endif + namespace detail { template -struct time_action +struct time_schedulable { - time_action(TimePoint when, action a) + time_schedulable(TimePoint when, schedulable a) : when(when) , a(std::move(a)) { } TimePoint when; - action a; + schedulable a; }; } diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 72c9133..9a46cfa 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -86,23 +86,26 @@ public: // observer // void on_next(T t) const { - if (is_subscribed()) { - detacher protect(this); - destination.on_next(std::move(t)); - protect.that = nullptr; + if (!is_subscribed()) { + abort(); } + detacher protect(this); + destination.on_next(std::move(t)); + protect.that = nullptr; } void on_error(std::exception_ptr e) const { - if (is_subscribed()) { - detacher protect(this); - destination.on_error(e); + if (!is_subscribed()) { + abort(); } + detacher protect(this); + destination.on_error(e); } void on_completed() const { - if (is_subscribed()) { - detacher protect(this); - destination.on_completed(); + if (!is_subscribed()) { + abort(); } + detacher protect(this); + destination.on_completed(); } // composite_subscription @@ -137,34 +140,34 @@ template struct observer_selector { template - static auto get_observer(Set&& rs) - -> decltype(std::get<5>(std::forward(rs)).value) { - return std::get<5>(std::forward(rs)).value; + static auto get_observer(Set& rs) + -> decltype(std::get<5>(rs).value) { + return std::get<5>(rs).value; } }; template struct observer_selector { template - static auto get_observer(Set&& rs) - -> decltype(make_observer_resolved(std::forward(rs))) { - return make_observer_resolved(std::forward(rs)); + static auto get_observer(Set& rs) + -> decltype(make_observer_resolved(rs)) { + return make_observer_resolved(rs); } }; template struct observer_selector { template - static auto get_observer(Set&& rs) - -> const decltype( std::get<6>(std::forward(rs)).value.get_observer())& { - return std::get<6>(std::forward(rs)).value.get_observer(); + static auto get_observer(Set& rs) + -> decltype( std::get<6>(rs).value.get_observer()) { + return std::get<6>(rs).value.get_observer(); } }; template -auto select_observer(ResolvedArgSet&& rs) - -> decltype(observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs))) { - return observer_selector(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg, std::decay(std::forward(rs)))>::type::is_arg>::get_observer(std::forward(rs)); +auto select_observer(ResolvedArgSet& rs) + -> decltype(observer_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs)) { + return observer_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs); typedef typename std::decay(std::forward(rs)))>::type rr_t; typedef typename std::decay(std::forward(rs)))>::type rn_t; @@ -187,7 +190,7 @@ auto make_subscriber_resolved(ResolvedArgSet&& rsArg) const auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : rr.value; const auto s = (rscrbr.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : rsub.value; return subscriber(std::move(rsArg)))>( - s, r, select_observer(std::move(rs))); + s, r, select_observer(rs)); // at least for now do not enforce resolver #if 0 @@ -198,16 +201,6 @@ auto make_subscriber_resolved(ResolvedArgSet&& rsArg) #endif } -struct tag_subscription_resolution -{ - template - struct predicate - { - static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; - }; - typedef composite_subscription default_type; -}; - template struct tag_subscriber_resolution { diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 6adba54..204bef8 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -23,6 +23,20 @@ public: static const bool value = std::is_convertible::type>(0)), tag_subscription>::value; }; +namespace detail { + +struct tag_subscription_resolution +{ + template + struct predicate + { + static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; + }; + typedef composite_subscription default_type; +}; + +} + class dynamic_subscription : public subscription_base { typedef std::function unsubscribe_call_type; @@ -139,6 +153,7 @@ public: typedef std::shared_ptr shared_subscription; typedef std::weak_ptr weak_subscription; private: + struct tag_empty {}; struct state_t : public std::enable_shared_from_this { std::vector subscriptions; @@ -150,6 +165,11 @@ private: { } + state_t(tag_empty&&) + : issubscribed(false) + { + } + bool is_subscribed() { return issubscribed; } @@ -217,6 +237,18 @@ private: mutable std::shared_ptr state; + static std::shared_ptr shared_empty; + + composite_subscription(std::shared_ptr s) + : state(std::move(s)) + { + if (!state) { + abort(); + } + } + + friend bool operator==(const composite_subscription&, const composite_subscription&); + public: composite_subscription() @@ -258,6 +290,10 @@ public: return *this; } + static composite_subscription empty() { + return composite_subscription(shared_empty); + } + bool is_subscribed() const { return state->is_subscribed(); } @@ -278,6 +314,17 @@ public: } }; +bool operator==(const composite_subscription& lhs, const composite_subscription& rhs) { + return lhs.state == rhs.state; +} +bool operator!=(const composite_subscription& lhs, const composite_subscription& rhs) { + return !(lhs == rhs); +} + +//static +RXCPP_SELECT_ANY std::shared_ptr composite_subscription::shared_empty = std::make_shared(composite_subscription::tag_empty()); + + } #endif -- GitLab From 2f7d4f683a3a1506b85cb2f080c9a58c22b43b15 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 22 Mar 2014 16:14:19 -0700 Subject: [PATCH 230/782] compiles on clang at least. --- Rx/v2/src/rxcpp/rx-observable.hpp | 4 +- Rx/v2/src/rxcpp/rx-regulator.hpp | 14 +- Rx/v2/src/rxcpp/rx-scheduler.hpp | 206 +++++++++--------- Rx/v2/src/rxcpp/rx-subscriber.hpp | 4 +- Rx/v2/src/rxcpp/rx-subscription.hpp | 58 ++--- .../src/rxcpp/schedulers/rx-currentthread.hpp | 68 +++--- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 57 ++--- Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 107 ++++----- Rx/v2/src/rxcpp/sources/rx-range.hpp | 6 +- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 12 +- Rx/v2/test/operators/filter.cpp | 15 +- Rx/v2/test/subjects/subject.cpp | 137 ++++++------ Rx/v2/test/subscriptions/observer.cpp | 10 +- 13 files changed, 359 insertions(+), 339 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 5c646ca..ede6c47 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -168,9 +168,9 @@ private: if (rxsc::current_thread::is_schedule_required()) { auto sc = rxsc::make_current_thread(); - sc->schedule([=](rxsc::action, rxsc::scheduler) { + schedule(sc, [=](const rxsc::schedulable& scbl) { safe_subscribe(); - return rxsc::make_action_empty(); + return rxsc::schedulable::empty(scbl.get_scheduler()); }); } else { safe_subscribe(); diff --git a/Rx/v2/src/rxcpp/rx-regulator.hpp b/Rx/v2/src/rxcpp/rx-regulator.hpp index 5cb4aff..e8bcdca 100644 --- a/Rx/v2/src/rxcpp/rx-regulator.hpp +++ b/Rx/v2/src/rxcpp/rx-regulator.hpp @@ -9,15 +9,6 @@ namespace rxcpp { -// temp to get compiling -namespace schedulers { - struct schedulable - { - schedulable& operator=(std::nullptr_t) {return *this;}; - void schedule() {} - }; -} - struct tag_resumption {}; struct resumption_base { @@ -96,8 +87,9 @@ public: inline void resume() { state->isresumed = true; auto resumewith = std::move(state->resumewith); - state->resumewith = nullptr; - resumewith.schedule(); + auto local = state->resumewith; + state->resumewith = rxsc::schedulable::empty(local.get_scheduler()); + local.schedule(); } inline resumption get_resumption() { return resumption(state); diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 98f2f9e..e59abbf 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -11,13 +11,15 @@ namespace rxcpp { namespace schedulers { +class scheduler_interface; + namespace detail { class action_type; typedef std::shared_ptr action_ptr; -class scheduler_interface; typedef std::shared_ptr scheduler_interface_ptr; +typedef std::shared_ptr const_scheduler_interface_ptr; } @@ -26,36 +28,6 @@ struct action_base typedef tag_action action_tag; }; -struct scheduler_base -{ - typedef tag_scheduler scheduler_tag; -}; - -class scheduler_interface - : public std::enable_shared_from_this -{ - typedef scheduler_interface this_type; - -public: - typedef std::chrono::steady_clock clock_type; - - virtual ~scheduler_interface() {} - - virtual clock_type::time_point now() const = 0; - - virtual bool is_tail_recursion_allowed() const = 0; - - virtual void schedule(composite_subscription cs, action a) const = 0; - virtual void schedule(clock_type::duration when, composite_subscription cs, action a) const = 0; - virtual void schedule(clock_type::time_point when, composite_subscription cs, action a) const = 0; -}; - - -struct schedulable_base : public subscription_base, public scheduler_base, public action_base -{ - typedef tag_schedulable schedulable_tag; -}; - class schedulable; namespace action_duration { @@ -77,7 +49,7 @@ public: { } explicit action(detail::action_ptr i) - : inner(std::move(i)) + : inner(std::move(i)) { } @@ -85,15 +57,43 @@ public: return action(shared_empty); } - inline action_duration::type get_duration() const { - return inner->get_duration(); - } + inline action_duration::type get_duration() const; inline void operator()(const schedulable& s) const; }; -//static -RXCPP_SELECT_ANY detail::action_ptr action::shared_empty = std::make_shared(); +struct scheduler_base +{ + typedef std::chrono::steady_clock clock_type; + typedef tag_scheduler scheduler_tag; +}; + +class schedulable; + +class scheduler_interface + : public std::enable_shared_from_this +{ + typedef scheduler_interface this_type; + +public: + typedef scheduler_base::clock_type clock_type; + + virtual ~scheduler_interface() {} + + virtual clock_type::time_point now() const = 0; + + virtual bool is_tail_recursion_allowed() const = 0; + + virtual void schedule(const schedulable& scbl) const = 0; + virtual void schedule(clock_type::duration when, const schedulable& scbl) const = 0; + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const = 0; +}; + + +struct schedulable_base : public subscription_base, public scheduler_base, public action_base +{ + typedef tag_schedulable schedulable_tag; +}; inline bool operator==(const action& lhs, const action& rhs) { return lhs.inner == rhs.inner; @@ -108,7 +108,7 @@ class scheduler : public scheduler_base detail::scheduler_interface_ptr inner; friend bool operator==(const scheduler&, const scheduler&); public: - typedef std::chrono::steady_clock clock_type; + typedef scheduler_base::clock_type clock_type; scheduler() { @@ -117,6 +117,10 @@ public: : inner(std::move(i)) { } + explicit scheduler(detail::const_scheduler_interface_ptr i) + : inner(std::const_pointer_cast(i)) + { + } inline clock_type::time_point now() const { return inner->now(); @@ -126,14 +130,14 @@ public: return inner->is_tail_recursion_allowed(); } - inline void schedule(composite_subscription cs, action a) const { - inner->schedule(std::move(cs), std::move(a)); + inline void schedule(const schedulable& scbl) const { + inner->schedule(scbl); } - inline void schedule(clock_type::duration when, composite_subscription cs, action a) const { - inner->schedule(when, std::move(cs), std::move(a)); + inline void schedule(clock_type::duration when, const schedulable& scbl) const { + inner->schedule(when, scbl); } - inline void schedule(clock_type::time_point when, composite_subscription cs, action a) const { - inner->schedule(when, std::move(cs), std::move(a)); + inline void schedule(clock_type::time_point when, const schedulable& scbl) const { + inner->schedule(when, scbl); } }; @@ -144,6 +148,12 @@ inline bool operator!=(const scheduler& lhs, const scheduler& rhs) { return !(lhs == rhs); } +template +inline scheduler make_scheduler() { + return scheduler(std::static_pointer_cast(std::make_shared())); +} + + class schedulable : public schedulable_base { typedef schedulable this_type; @@ -170,7 +180,7 @@ class schedulable : public schedulable_base public: typedef typename composite_subscription::weak_subscription weak_subscription; typedef typename composite_subscription::shared_subscription shared_subscription; - typedef std::chrono::steady_clock clock_type; + typedef scheduler_base::clock_type clock_type; schedulable() { @@ -201,8 +211,8 @@ public: return activity; } - inline static schedulable empty() { - return schedulable(composite_subscription::empty(), controller, action::empty()); + inline static schedulable empty(scheduler sc) { + return schedulable(composite_subscription::empty(), sc, action::empty()); } // composite_subscription @@ -235,13 +245,13 @@ public: return controller.is_tail_recursion_allowed(); } inline void schedule() const { - controller.schedule(lifetime, activity); + controller.schedule(*this); } inline void schedule(clock_type::duration when) const { - controller.schedule(when, lifetime, activity); + controller.schedule(when, *this); } inline void schedule(clock_type::time_point when) const { - controller.schedule(when, lifetime, activity); + controller.schedule(when, *this); } // action @@ -268,14 +278,7 @@ inline bool operator!=(const schedulable& lhs, const schedulable& rhs) { return !(lhs == rhs); } - -inline void action::operator()(const schedulable& s) const { - auto next = (*inner)(s); - if (next.is_subscribed()) { - next.schedule(); - } -} - +struct current_thread; namespace detail { @@ -310,14 +313,30 @@ public: if (f) { return f(s); } - return schedulable::empty(); + return schedulable::empty(make_scheduler()); } }; } + +inline action_duration::type action::get_duration() const { + return inner->get_duration(); +} + +inline void action::operator()(const schedulable& s) const { + auto next = (*inner)(s); + if (next.is_subscribed()) { + next.schedule(); + } +} + +//static +RXCPP_SELECT_ANY detail::action_ptr action::shared_empty = detail::action_ptr(new detail::action_type()); + + inline action make_action_empty() { - return action_type::empty(); + return action::empty(); } template @@ -338,11 +357,6 @@ inline action make_action(F&& f, action_duration::type d = action_duration::runs })); } -template -inline scheduler make_scheduler() { - return scheduler(std::static_pointer_cast(std::make_shared())); -} - namespace detail { template @@ -375,7 +389,7 @@ struct tag_action_duration_resolution static const bool value = std::is_same::type, action_duration::type>::value; }; struct default_type { - inline operator action_duration::type() { + inline operator action_duration::type() const { return action_duration::runs_short; } }; @@ -385,7 +399,7 @@ struct tag_when_resolution { typedef scheduler_interface::clock_type clock_type; typedef clock_type::duration duration_type; - typedef clock_type::duration time_point_type; + typedef clock_type::time_point time_point_type; template struct predicate { @@ -394,7 +408,7 @@ struct tag_when_resolution std::is_same::value; }; struct default_type { - inline operator time_point_type() { + inline operator time_point_type() const { return clock_type::now(); } }; @@ -430,36 +444,35 @@ struct tag_scheduler_resolution }; -template struct tag_schedulable_set // the first four must be the same as tag_observer_set or the indexing will fail - : public rxu::detail::tag_set, + : public rxu::detail::tag_set, + rxu::detail::tag_set>>>>>> { }; -template +template struct action_selector; -template -struct action_selector +template +struct action_selector { template static action get_action(Set& rs) { return std::get<4>(rs).value; } }; -template -struct action_selector +template +struct action_selector { template static action get_action(Set& rs) { - return make_action(std::move(std::get<5>(rs).value), std::get<6>(rs).value); + return make_action(std::get<5>(rs).value, std::get<6>(rs).value); } }; template<> @@ -472,9 +485,8 @@ struct action_selector }; template -action select_action(ResolvedArgSet& rs) - -> decltype(action_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs)) { - return action_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs); +action select_action(ResolvedArgSet& rs) { + return action_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_action(rs); typedef typename std::decay(std::forward(rs)))>::type rsc_t; typedef typename std::decay(std::forward(rs)))>::type raf_t; @@ -493,23 +505,23 @@ schedulable make_schedulable_resolved(ResolvedArgSet&& rsArg) { const auto rsub = std::get<2>(rs); const auto rsc = std::get<3>(rs); const auto rscbl = std::get<1>(rs); - const auto sc = (rscbl.is_arg && !rsc.is_arg) ? rscrbr.value.get_scheduler() : rsc.value; - const auto sub = (rscbl.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : rsub.value; + const auto sc = (rscbl.is_arg && !rsc.is_arg) ? rscbl.value.get_scheduler() : rsc.value; + const auto sub = (rscbl.is_arg && !rsub.is_arg) ? rscbl.value.get_subscription() : rsub.value; return schedulable(sub, sc, select_action(rs)); - typedef typename std::decay(std::forward(rs)))>::type rw_t; - typedef typename std::decay(std::forward(rs)))>::type rsc_t; - typedef typename std::decay(std::forward(rs)))>::type rscbl_t; + typedef typename std::decay(rs))>::type rw_t; + typedef typename std::decay(rs))>::type rsc_t; + typedef typename std::decay(rs))>::type rscbl_t; static_assert(when_invalid || !rw_t::is_arg, "when is an invalid parameter"); static_assert(rscbl_t::is_arg || rsc_t::is_arg, "at least one of; scheduler or schedulable is required"); } -template +template schedulable schedule_resolved(ResolvedArgSet&& rsArg) { + const auto rw = std::get<0>(rsArg); schedulable result = make_schedulable_resolved(std::forward(rsArg)); - const auto rw = std::get<0>(rs); - if (rx.is_arg) { + if (rw.is_arg) { result.schedule(rw.value); } else { result.schedule(); @@ -550,28 +562,28 @@ schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& #if RXCPP_USE_VARIADIC_TEMPLATES template schedulable schedule(Arg0&& a0, ArgN&&... an) { - detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); + return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); } #else template schedulable schedule(Arg0&& a0) { - detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0))); + return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0))); } template schedulable schedule(Arg0&& a0, Arg1&& a1) { - detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1))); + return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1))); } template schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2) { - detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2))); + return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2))); } template schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) { - detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); + return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } template schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) { - detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); + return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } #endif @@ -582,11 +594,11 @@ struct time_schedulable { time_schedulable(TimePoint when, schedulable a) : when(when) - , a(std::move(a)) + , what(std::move(a)) { } TimePoint when; - schedulable a; + schedulable what; }; } diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 9a46cfa..91086d8 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -182,14 +182,14 @@ auto select_observer(ResolvedArgSet& rs) template auto make_subscriber_resolved(ResolvedArgSet&& rsArg) - -> subscriber(std::move(rsArg)))> { + -> subscriber(*(typename std::decay::type*)nullptr))> { const auto rs = std::forward(rsArg); const auto rsub = std::get<3>(rs); const auto rr = std::get<4>(rs); const auto rscrbr = std::get<6>(rs); const auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : rr.value; const auto s = (rscrbr.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : rsub.value; - return subscriber(std::move(rsArg)))>( + return subscriber(*(typename std::decay::type*)nullptr))>( s, r, select_observer(rs)); // at least for now do not enforce resolver diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 204bef8..b6c8d6f 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -23,20 +23,6 @@ public: static const bool value = std::is_convertible::type>(0)), tag_subscription>::value; }; -namespace detail { - -struct tag_subscription_resolution -{ - template - struct predicate - { - static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; - }; - typedef composite_subscription default_type; -}; - -} - class dynamic_subscription : public subscription_base { typedef std::function unsubscribe_call_type; @@ -170,15 +156,15 @@ private: { } - bool is_subscribed() { + inline bool is_subscribed() { return issubscribed; } - weak_subscription add(dynamic_subscription s) { + inline weak_subscription add(dynamic_subscription s) { return add(std::make_shared(std::move(s))); } - weak_subscription add(shared_subscription s) { + inline weak_subscription add(shared_subscription s) { std::unique_lock guard(lock); if (!issubscribed) { @@ -194,7 +180,7 @@ private: return s; } - void remove(weak_subscription w) { + inline void remove(weak_subscription w) { std::unique_lock guard(lock); if (issubscribed) { @@ -211,7 +197,7 @@ private: } } - void clear() { + inline void clear() { std::unique_lock guard(lock); if (issubscribed) { @@ -222,7 +208,7 @@ private: } } - void unsubscribe() { + inline void unsubscribe() { std::unique_lock guard(lock); if (issubscribed) { @@ -290,34 +276,34 @@ public: return *this; } - static composite_subscription empty() { + static inline composite_subscription empty() { return composite_subscription(shared_empty); } - bool is_subscribed() const { + inline bool is_subscribed() const { return state->is_subscribed(); } - weak_subscription add(shared_subscription s) const { + inline weak_subscription add(shared_subscription s) const { return state->add(std::move(s)); } - weak_subscription add(dynamic_subscription s) const { + inline weak_subscription add(dynamic_subscription s) const { return state->add(std::move(s)); } - void remove(weak_subscription w) const { + inline void remove(weak_subscription w) const { state->remove(std::move(w)); } - void clear() const { + inline void clear() const { state->clear(); } - void unsubscribe() const { + inline void unsubscribe() const { state->unsubscribe(); } }; -bool operator==(const composite_subscription& lhs, const composite_subscription& rhs) { +inline bool operator==(const composite_subscription& lhs, const composite_subscription& rhs) { return lhs.state == rhs.state; } -bool operator!=(const composite_subscription& lhs, const composite_subscription& rhs) { +inline bool operator!=(const composite_subscription& lhs, const composite_subscription& rhs) { return !(lhs == rhs); } @@ -325,6 +311,20 @@ bool operator!=(const composite_subscription& lhs, const composite_subscription& RXCPP_SELECT_ANY std::shared_ptr composite_subscription::shared_empty = std::make_shared(composite_subscription::tag_empty()); +namespace detail { + + struct tag_subscription_resolution + { + template + struct predicate + { + static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; + }; + typedef composite_subscription default_type; + }; + +} + } #endif diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 205c93d..f5f2b85 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -18,7 +18,7 @@ struct action_queue typedef action_queue this_type; typedef scheduler_base::clock_type clock; - typedef time_action item_type; + typedef time_schedulable item_type; private: struct compare_item_time @@ -73,7 +73,7 @@ public: if (!current_thread_queue()) { abort(); } - if (!item.a->is_subscribed()) { + if (!item.what.is_subscribed()) { return; } current_thread_queue()->queue.push(std::move(item)); @@ -114,7 +114,7 @@ public: } -struct current_thread : public scheduler_base +struct current_thread : public scheduler_interface { private: typedef current_thread this_type; @@ -122,7 +122,7 @@ private: typedef detail::action_queue queue; - struct derecurser : public scheduler_base + struct derecurser : public scheduler_interface { private: typedef current_thread this_type; @@ -135,20 +135,24 @@ private: { } - virtual clock_type::time_point now() { + virtual clock_type::time_point now() const { return clock_type::now(); } - virtual void schedule(action a) { - queue::push(queue::item_type(now(), std::move(a))); + inline bool is_tail_recursion_allowed() const { + return queue::empty(); } - virtual void schedule(clock_type::duration when, action a) { - queue::push(queue::item_type(now() + when, std::move(a))); + virtual void schedule(const schedulable& scbl) const { + queue::push(queue::item_type(now(), scbl)); } - virtual void schedule(clock_type::time_point when, action a) { - queue::push(queue::item_type(when, std::move(a))); + virtual void schedule(clock_type::duration when, const schedulable& scbl) const { + queue::push(queue::item_type(now() + when, scbl)); + } + + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + queue::push(queue::item_type(when, scbl)); } }; @@ -160,41 +164,45 @@ public: { } - static bool is_schedule_required() { return !queue::get_scheduler(); } + static bool is_schedule_required() { return queue::get_scheduler() == scheduler(); } - virtual clock_type::time_point now() { + virtual clock_type::time_point now() const { return clock_type::now(); } - virtual void schedule(action a) { - schedule(now(), std::move(a)); + inline bool is_tail_recursion_allowed() const { + return queue::empty(); + } + + virtual void schedule(const schedulable& scbl) const { + schedule(now(), scbl); } - virtual void schedule(clock_type::duration when, action a) { - schedule(now() + when, std::move(a)); + virtual void schedule(clock_type::duration when, const schedulable& scbl) const { + schedule(now() + when, scbl); } - virtual void schedule(clock_type::time_point when, action a) { - if (!a->is_subscribed()) { + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + if (!scbl.is_subscribed()) { return; } auto sc = queue::get_scheduler(); // check ownership - if (!!sc) + if (sc != scheduler()) { // already has an owner - delegate - return sc->schedule(when, std::move(a)); + return sc.schedule(when, scbl); } // take ownership - sc = queue::ensure(std::make_shared()); + sc = queue::ensure(make_scheduler()); RXCPP_UNWIND_AUTO([]{ queue::destroy(); }); - queue::push(queue::item_type(when, std::move(a))); + queue::push(queue::item_type(when, scbl)); // loop until queue is empty for ( @@ -203,18 +211,12 @@ public: when = queue::top().when ) { - auto a = queue::top().a; + auto what = queue::top().what; queue::pop(); - while (a->is_subscribed()) { - a = (*a)(sc); - if (!queue::empty()) { - // take proper place in line - sc->schedule(std::move(a)); - break; - } - // tail recurse to a + if (what.is_subscribed()) { + what.get_action()(what); } if (queue::empty()) { @@ -225,7 +227,7 @@ public: }; inline scheduler make_current_thread() { - return std::make_shared(); + return make_scheduler(); } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 60dcff9..4d0ab00 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -67,7 +67,7 @@ public: using base::schedule_absolute; using base::schedule_relative; - virtual void schedule_absolute(long when, action a) + virtual void schedule_absolute(long when, action a) const { if (when <= base::clock_now) when = base::clock_now + 1; @@ -75,17 +75,17 @@ public: return base::schedule_absolute(when, std::move(a)); } - virtual long add(long absolute, long relative) + virtual long add(long absolute, long relative) const { return absolute + relative; } - virtual clock_type::time_point to_time_point(long absolute) + virtual clock_type::time_point to_time_point(long absolute) const { return clock_type::time_point(clock_type::duration(absolute)); } - virtual long to_relative(clock_type::duration d) + virtual long to_relative(clock_type::duration d) const { return static_cast(d.count()); } @@ -93,7 +93,7 @@ public: using base::start; template - auto start(F&& createSource, long created, long subscribed, long unsubscribed) + auto start(F&& createSource, long created, long subscribed, long unsubscribed) const -> subscriber> { typename std::decay::type createSrc = std::forward(createSource); @@ -114,17 +114,17 @@ public: }; std::shared_ptr state(new state_type(this->make_subscriber())); - schedule_absolute(created, make_action([createSrc, state](action, scheduler) { + schedule_absolute(created, make_action([createSrc, state](const schedulable& scbl) { state->source.reset(new typename state_type::source_type(createSrc())); - return make_action_empty(); + return schedulable::empty(scbl.get_scheduler()); })); - schedule_absolute(subscribed, make_action([state](action, scheduler) { + schedule_absolute(subscribed, make_action([state](const schedulable& scbl) { state->source->subscribe(state->o); - return make_action_empty(); + return schedulable::empty(scbl.get_scheduler()); })); - schedule_absolute(unsubscribed, make_action([state](action, scheduler) { + schedule_absolute(unsubscribed, make_action([state](const schedulable& scbl) { state->o.unsubscribe(); - return make_action_empty(); + return schedulable::empty(scbl.get_scheduler()); })); start(); @@ -133,39 +133,39 @@ public: } template - auto start(F&& createSource, long unsubscribed) + auto start(F&& createSource, long unsubscribed) const -> subscriber> { return start(std::forward(createSource), created_time, subscribed_time, unsubscribed); } template - auto start(F&& createSource) + auto start(F&& createSource) const -> subscriber> { return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); } template - rxt::testable_observable make_hot_observable(std::vector>>> messages); + rxt::testable_observable make_hot_observable(std::vector>>> messages) const; template - auto make_hot_observable(const T (&arr) [size]) + auto make_hot_observable(const T (&arr) [size]) const -> decltype(make_hot_observable(std::vector())) { return make_hot_observable(rxu::to_vector(arr)); } template - rxt::testable_observable make_cold_observable(std::vector>>> messages); + rxt::testable_observable make_cold_observable(std::vector>>> messages) const; template - auto make_cold_observable(const T (&arr) [size]) + auto make_cold_observable(const T (&arr) [size]) const -> decltype(make_cold_observable(std::vector())) { return make_cold_observable(rxu::to_vector(arr)); } template - subscriber> make_subscriber(); + subscriber> make_subscriber() const; }; template @@ -213,12 +213,12 @@ public: }; template -subscriber> test::make_subscriber() +subscriber> test::make_subscriber() const { typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - std::shared_ptr> ts(new mock_observer(std::static_pointer_cast(shared_from_this()))); + std::shared_ptr> ts(new mock_observer(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())))); return rxcpp::make_subscriber(rxt::testable_observer(ts, make_observer_dynamic( // on_next @@ -272,9 +272,10 @@ public: for (auto& message : mv) { auto n = message.value(); - sc->schedule_relative(message.time(), make_action([n, o](action, scheduler) { + sc->schedule_relative(message.time(), make_action([n, o](const schedulable& scbl) { n->accept(o); - return make_action_empty(); + scbl.unsubscribe(); + return scbl; })); } @@ -294,9 +295,9 @@ public: }; template -rxt::testable_observable test::make_cold_observable(std::vector>>> messages) +rxt::testable_observable test::make_cold_observable(std::vector>>> messages) const { - auto co = std::shared_ptr>(new cold_observable(std::static_pointer_cast(shared_from_this()), std::move(messages))); + auto co = std::shared_ptr>(new cold_observable(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); return rxt::testable_observable(co); } @@ -320,12 +321,12 @@ public: { for (auto& message : mv) { auto n = message.value(); - sc->schedule_absolute(message.time(), make_action([this, n](action, scheduler) { + sc->schedule_absolute(message.time(), make_action([this, n](const schedulable& scbl) { auto local = this->observers; for (auto& o : local) { n->accept(o); } - return make_action_empty(); + return schedulable::empty(scbl.get_scheduler()); })); } } @@ -351,10 +352,10 @@ public: }; template -rxt::testable_observable test::make_hot_observable(std::vector>>> messages) +rxt::testable_observable test::make_hot_observable(std::vector>>> messages) const { return rxt::testable_observable(std::make_shared>( - std::static_pointer_cast(shared_from_this()), std::move(messages))); + std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index 42f87f8..169bad1 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -14,13 +14,13 @@ namespace schedulers { namespace detail { template -struct virtual_time_base : public scheduler_base +struct virtual_time_base : public scheduler_interface { private: typedef virtual_time_base this_type; virtual_time_base(const virtual_time_base&); - bool isenabled; + mutable bool isenabled; public: typedef Absolute absolute; @@ -42,57 +42,54 @@ protected: { } - absolute clock_now; + mutable absolute clock_now; - typedef time_action item_type; + typedef time_schedulable item_type; - virtual absolute add(absolute, relative) =0; + virtual absolute add(absolute, relative) const =0; - virtual typename scheduler_base::clock_type::time_point to_time_point(absolute) =0; - virtual relative to_relative(typename scheduler_base::clock_type::duration) =0; + virtual typename scheduler_base::clock_type::time_point to_time_point(absolute) const =0; + virtual relative to_relative(typename scheduler_base::clock_type::duration) const =0; - virtual item_type top() =0; - virtual void pop() =0; - virtual bool empty() =0; + virtual item_type top() const =0; + virtual void pop() const =0; + virtual bool empty() const =0; public: - virtual void schedule_absolute(absolute, action) =0; + virtual void schedule_absolute(absolute, action) const =0; template - typename std::enable_if::type, action>::value, void>::type - schedule_absolute(absolute when, F f) { + typename std::enable_if::type, action>::value, void>::type + schedule_absolute(absolute when, F f) const { schedule_absolute(when, make_action(f)); } - virtual void schedule_relative(relative when, action a) { + virtual void schedule_relative(relative when, action a) const { auto at = add(clock_now, when); return schedule_absolute(at, std::move(a)); } template - typename std::enable_if::type, action>::value, void>::type - schedule_relative(relative when, F f) { + typename std::enable_if::type, action>::value, void>::type + schedule_relative(relative when, F f) const { schedule_relative(when, make_action(f)); } - bool is_enabled() {return isenabled;} - absolute clock() {return clock_now;} + bool is_enabled() const {return isenabled;} + absolute clock() const {return clock_now;} - void start() + void start() const { if (!isenabled) { isenabled = true; while (!empty() && isenabled) { auto next = top(); pop(); - if (next.a->is_subscribed()) { + if (next.what.is_subscribed()) { if (next.when > clock_now) { clock_now = next.when; } - auto a = (*next.a)(shared_from_this()); - if (a->is_subscribed()) { - schedule(a); - } + next.what.get_action()(next.what); } else { isenabled = false; @@ -101,12 +98,12 @@ public: } } - void stop() + void stop() const { isenabled = false; } - void advance_to(absolute time) + void advance_to(absolute time) const { if (time < clock_now) { abort(); @@ -121,14 +118,11 @@ public: while (!empty() && isenabled) { auto next = top(); pop(); - if (next.a->is_subscribed() && next.when <= time) { + if (next.what.is_subscribed() && next.when <= time) { if (next.when > clock_now) { clock_now = next.when; } - auto a = (*next.a)(shared_from_this()); - if (a.subscribed()) { - schedule(a); - } + next.what.get_action()(next.what); } else { isenabled = false; @@ -142,7 +136,7 @@ public: } } - void advance_by(relative time) + void advance_by(relative time) const { auto dt = add(clock_now, time); @@ -162,7 +156,7 @@ public: } } - void sleep(relative time) + void sleep(relative time) const { auto dt = add(clock_now, time); @@ -173,20 +167,24 @@ public: clock_now = dt; } - virtual clock_type::time_point now() { + virtual clock_type::time_point now() const { return to_time_point(clock_now); } - virtual void schedule(action a) { - schedule_absolute(clock_now, std::move(a)); + virtual bool is_tail_recursion_allowed() const { + return false; + } + + virtual void schedule(const schedulable& scbl) const { + schedule_absolute(clock_now, scbl.get_action()); } - virtual void schedule(clock_type::duration when, action a) { - schedule_absolute(to_relative(when), std::move(a)); + virtual void schedule(clock_type::duration when, const schedulable& scbl) const { + schedule_absolute(to_relative(when), scbl.get_action()); } - virtual void schedule(clock_type::time_point when, action a) { - schedule_absolute(to_relative(when - now()), std::move(a)); + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + schedule_absolute(to_relative(when - now()), scbl.get_action()); } }; @@ -197,7 +195,8 @@ template class virtual_time : public detail::virtual_time_base { private: - virtual_time(const virtual_time&); + typedef virtual_time this_type; + virtual_time(const this_type&); typedef detail::virtual_time_base base; @@ -216,7 +215,7 @@ private: compare_item_time > queue_item_time; - queue_item_time queue; + mutable queue_item_time queue; public: virtual ~virtual_time() @@ -232,29 +231,31 @@ protected: { } - virtual item_type top() { + virtual item_type top() const { return queue.top(); } - virtual void pop() { + virtual void pop() const { queue.pop(); } - virtual bool empty() { + virtual bool empty() const { return queue.empty(); } using base::schedule_absolute; using base::schedule_relative; - virtual void schedule_absolute(typename base::absolute when, action a) + virtual void schedule_absolute(typename base::absolute when, action a) const { // use a separate subscription here so that a's subscription is not affected - auto run = make_action([a](action that, scheduler sc) { - if (that->is_subscribed()) { - that->unsubscribe(); // unsubscribe() run, not a; - (*a)(sc); - } - return make_action_empty(); - }); + auto run = make_schedulable( + scheduler(this->shared_from_this()), + [a](const schedulable& scbl) { + if (scbl.is_subscribed()) { + scbl.unsubscribe(); // unsubscribe() run, not a; + a(scbl); + } + return schedulable::empty(scbl.get_scheduler()); + }); queue.push(item_type(when, run)); } diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index 418c292..d7514c1 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -34,14 +34,14 @@ struct range : public source_base template void on_subscribe(Subscriber o) { auto state = std::make_shared(init); - state->sc->schedule(o.get_subscription(), [=](rxsc::action that, rxsc::scheduler){ + schedule(state->sc, o.get_subscription(), [=](rxsc::schedulable scbl){ if (state->remaining == 0) { o.on_completed(); // o is unsubscribed } if (!o.is_subscribed()) { // terminate loop - return rxsc::make_action_empty(); + return scbl; } // send next value @@ -50,7 +50,7 @@ struct range : public source_base state->next = static_cast(state->step + state->next); // tail recurse this same action to continue loop - return that; + return scbl; }); } }; diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index bf4d1a8..ff853ec 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -148,7 +148,9 @@ public: c = b->completer; } for (auto& o : c->observers) { - o.on_next(t); + if (o.is_subscribed()) { + o.on_next(t); + } } } } @@ -161,7 +163,9 @@ public: guard.unlock(); if (c) { for (auto& o : c->observers) { - o.on_error(e); + if (o.is_subscribed()) { + o.on_error(e); + } } } } @@ -174,7 +178,9 @@ public: guard.unlock(); if (c) { for (auto& o : c->observers) { - o.on_completed(); + if (o.is_subscribed()) { + o.on_completed(); + } } } } diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index ad92bbb..f68fb4c 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -396,7 +396,7 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") WHEN("filtered to ints that are primes"){ sc->schedule_absolute(rxsc::test::created_time, - [&invoked, &res, &ys, &xs](rxsc::action, rxsc::scheduler) { + [&invoked, &res, &ys, &xs](const rxsc::schedulable& scbl) { #if RXCPP_USE_OBSERVABLE_MEMBERS ys = xs .filter([&invoked, &res](int x) { @@ -414,17 +414,20 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") return IsPrime(x); }); #endif - return rxsc::make_action_empty(); + scbl.unsubscribe(); + return scbl; }); - sc->schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](rxsc::action, rxsc::scheduler) { + sc->schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl) { ys.subscribe(res); - return rxsc::make_action_empty(); + scbl.unsubscribe(); + return scbl; }); - sc->schedule_absolute(rxsc::test::unsubscribed_time, [&res](rxsc::action, rxsc::scheduler) { + sc->schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl) { res.unsubscribe(); - return rxsc::make_action_empty(); + scbl.unsubscribe(); + return scbl; }); sc->start(); diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 620863a..bac779b 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -43,7 +43,10 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ int c = 0; int n = 1; auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe([&c](int){++c;}); + rxs::range(0, onnextcalls).subscribe( + [&c](int){ + ++c; + }); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); @@ -181,28 +184,28 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s, &o](rxsc::action, rxsc::scheduler){ - s = rxsub::subject(); o = s.get_subscriber(); return rxsc::make_action_empty();}); - sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ - xs.subscribe(o); return rxsc::make_action_empty();}); - sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ - o.unsubscribe(); return rxsc::make_action_empty();}); - - sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); - sc->schedule_absolute(400, [&s, &results2](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results2); return rxsc::make_action_empty();}); - sc->schedule_absolute(900, [&s, &results3](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results3); return rxsc::make_action_empty();}); - - sc->schedule_absolute(600, [&results1](rxsc::action, rxsc::scheduler){ - results1.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(700, [&results2](rxsc::action, rxsc::scheduler){ - results2.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(800, [&results1](rxsc::action, rxsc::scheduler){ - results1.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(950, [&results3](rxsc::action, rxsc::scheduler){ - results3.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + s = rxsub::subject(); o = s.get_subscriber(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + xs.subscribe(o); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + o.unsubscribe(); scbl.unsubscribe(); return scbl;}); + + sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results1); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results2); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results3); scbl.unsubscribe(); return scbl;}); + + sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + results2.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + results3.unsubscribe(); scbl.unsubscribe(); return scbl;}); sc->start(); @@ -274,28 +277,28 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s, &o](rxsc::action, rxsc::scheduler){ - s = rxsub::subject(); o = s.get_subscriber(); return rxsc::make_action_empty();}); - sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ - xs.subscribe(o); return rxsc::make_action_empty();}); - sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ - o.unsubscribe(); return rxsc::make_action_empty();}); - - sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); - sc->schedule_absolute(400, [&s, &results2](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results2); return rxsc::make_action_empty();}); - sc->schedule_absolute(900, [&s, &results3](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results3); return rxsc::make_action_empty();}); - - sc->schedule_absolute(600, [&results1](rxsc::action, rxsc::scheduler){ - results1.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(700, [&results2](rxsc::action, rxsc::scheduler){ - results2.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(800, [&results1](rxsc::action, rxsc::scheduler){ - results1.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(950, [&results3](rxsc::action, rxsc::scheduler){ - results3.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + s = rxsub::subject(); o = s.get_subscriber(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + xs.subscribe(o); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + o.unsubscribe(); scbl.unsubscribe(); return scbl;}); + + sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results1); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results2); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results3); scbl.unsubscribe(); return scbl;}); + + sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + results2.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + results3.unsubscribe(); scbl.unsubscribe(); return scbl;}); sc->start(); @@ -370,28 +373,28 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s, &o](rxsc::action, rxsc::scheduler){ - s = rxsub::subject(); o = s.get_subscriber(); return rxsc::make_action_empty();}); - sc->schedule_absolute(200, [&xs, &o](rxsc::action, rxsc::scheduler){ - xs.subscribe(o); return rxsc::make_action_empty();}); - sc->schedule_absolute(1000, [&o](rxsc::action, rxsc::scheduler){ - o.unsubscribe(); return rxsc::make_action_empty();}); - - sc->schedule_absolute(300, [&s, &results1](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results1); return rxsc::make_action_empty();}); - sc->schedule_absolute(400, [&s, &results2](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results2); return rxsc::make_action_empty();}); - sc->schedule_absolute(900, [&s, &results3](rxsc::action, rxsc::scheduler){ - s.get_observable().subscribe(results3); return rxsc::make_action_empty();}); - - sc->schedule_absolute(600, [&results1](rxsc::action, rxsc::scheduler){ - results1.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(700, [&results2](rxsc::action, rxsc::scheduler){ - results2.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(800, [&results1](rxsc::action, rxsc::scheduler){ - results1.unsubscribe(); return rxsc::make_action_empty();}); - sc->schedule_absolute(950, [&results3](rxsc::action, rxsc::scheduler){ - results3.unsubscribe(); return rxsc::make_action_empty();}); + sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + s = rxsub::subject(); o = s.get_subscriber(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + xs.subscribe(o); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + o.unsubscribe(); scbl.unsubscribe(); return scbl;}); + + sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results1); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results2); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + s.get_observable().subscribe(results3); scbl.unsubscribe(); return scbl;}); + + sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + results2.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + results3.unsubscribe(); scbl.unsubscribe(); return scbl;}); sc->start(); diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 1bed6b6..1d1f002 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -12,13 +12,13 @@ SCENARIO("subscriber traits", "[observer][traits]"){ // auto ra = rx::rxu::detail::arg_resolver_n<0, rx::tag_resumption_resolution::template predicate, typename rx::tag_resumption_resolution::default_type, rx::resumption, decltype(next), decltype(error), decltype(completed), rx::rxu::detail::tag_unresolvable, rx::rxu::detail::tag_unresolvable>(rx::resumption(), next, error, completed, rx::rxu::detail::tag_unresolvable(), rx::rxu::detail::tag_unresolvable()); // auto ra = typename rx::rxu::detail::arg_resolver::type(rx::resumption(), next, error, completed, rx::rxu::detail::tag_unresolvable(), rx::rxu::detail::tag_unresolvable()); // auto arg = rx::rxu::detail::resolve_arg(rx::resumption(), next, error, completed); -// auto argset = rx::rxu::detail::resolve_arg_set(rx::tag_subscriber_set(), rx::resumption(), next, error, completed); -// auto o = rx::make_observer_resolved(argset); -// auto o = rx::select_observer(argset); +// auto argset = rx::rxu::detail::resolve_arg_set(rxcpp::detail::tag_subscriber_set(), rx::resumption(), next, error, completed); +// auto o = rx::detail::make_observer_resolved(argset); +// auto o = rx::detail::select_observer(argset); // auto scrbResult = rx::subscriber(std::move(std::get<0>(argset).value), std::move(std::get<1>(argset).value), o); // static_assert(std::tuple_element<1, decltype(argset)>::type::is_arg, "resumption is a required parameter"); -// auto scrbResult = rx::make_subscriber_resolved(rx::rxu::detail::resolve_arg_set(rx::tag_subscriber_set(), rx::resumption(), next, error, completed)); -// auto scrbResult = rx::make_subscriber_resolved(argset); +// auto scrbResult = rx::detail::make_subscriber_resolved(rx::rxu::detail::resolve_arg_set(rx::detail::tag_subscriber_set(), rx::resumption(), next, error, completed)); +// auto scrbResult = rx::detail::make_subscriber_resolved(argset); auto scrbResult = rx::make_subscriber(rx::resumption(), next, error, completed); auto scrbdup = rx::make_subscriber(scrbResult); auto scrbop = rx::make_subscriber(scrbResult, next, error, completed); -- GitLab From 31c9787d25d5c296ed74d3746f5ed0b8e8a657ba Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 23 Mar 2014 13:58:52 -0700 Subject: [PATCH 231/782] restructuring tail-recursion to make range and for-loop perf similar when no marble schedules to the current thread. --- Rx/v2/src/rxcpp/rx-observable.hpp | 1 - Rx/v2/src/rxcpp/rx-scheduler.hpp | 170 ++++++++++++++---- Rx/v2/src/rxcpp/rx-subscription.hpp | 18 +- .../src/rxcpp/schedulers/rx-currentthread.hpp | 30 ++-- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 3 - Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 13 +- Rx/v2/src/rxcpp/sources/rx-range.hpp | 6 +- Rx/v2/test/subjects/subject.cpp | 60 +++---- 8 files changed, 208 insertions(+), 93 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index ede6c47..6a57bf4 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -170,7 +170,6 @@ private: auto sc = rxsc::make_current_thread(); schedule(sc, [=](const rxsc::schedulable& scbl) { safe_subscribe(); - return rxsc::schedulable::empty(scbl.get_scheduler()); }); } else { safe_subscribe(); diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index e59abbf..6bd5a8b 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -23,6 +23,69 @@ typedef std::shared_ptr const_scheduler_interface_ptr } +class recursed +{ + bool& isrequested; +public: + explicit recursed(bool& r) + : isrequested(r) + { + } + inline void operator()() const { + isrequested = true; + } +}; + +class recurse +{ + bool& isallowed; + mutable bool isrequested; + recursed requestor; +public: + explicit recurse(bool& a) + : isallowed(a) + , isrequested(true) + , requestor(isrequested) + { + } + inline bool is_allowed() const { + return isallowed; + } + inline bool is_requested() const { + return isrequested; + } + inline void reset() const { + isrequested = false; + } + inline const recursed& get_recursed() const { + return requestor; + } +}; + +class recursion +{ + mutable bool isallowed; + recurse recursor; +public: + recursion() + : isallowed(true) + , recursor(isallowed) + { + } + explicit recursion(bool b) + : isallowed(b) + , recursor(isallowed) + { + } + inline void reset(bool b = true) const { + isallowed = b; + } + inline const recurse& get_recurse() const { + return recursor; + } +}; + + struct action_base { typedef tag_action action_tag; @@ -59,7 +122,7 @@ public: inline action_duration::type get_duration() const; - inline void operator()(const schedulable& s) const; + inline void operator()(const schedulable& s, const recurse& r) const; }; struct scheduler_base @@ -82,8 +145,6 @@ public: virtual clock_type::time_point now() const = 0; - virtual bool is_tail_recursion_allowed() const = 0; - virtual void schedule(const schedulable& scbl) const = 0; virtual void schedule(clock_type::duration when, const schedulable& scbl) const = 0; virtual void schedule(clock_type::time_point when, const schedulable& scbl) const = 0; @@ -126,10 +187,6 @@ public: return inner->now(); } - inline bool is_tail_recursion_allowed() const { - return inner->is_tail_recursion_allowed(); - } - inline void schedule(const schedulable& scbl) const { inner->schedule(scbl); } @@ -177,6 +234,48 @@ class schedulable : public schedulable_base const this_type* that; }; + class recursed_scope_type + { + mutable const recursed* requestor; + + class exit_recursed_scope_type + { + const recursed_scope_type* that; + public: + ~exit_recursed_scope_type() + { + that->requestor = nullptr; + } + exit_recursed_scope_type(const recursed_scope_type* that) + : that(that) + { + } + }; + public: + recursed_scope_type() + : requestor(nullptr) + { + } + recursed_scope_type(const recursed_scope_type&) + : requestor(nullptr) + { + // does not aquire recursion scope + } + recursed_scope_type& operator=(const recursed_scope_type& o) + { + // no change in recursion scope + return *this; + } + exit_recursed_scope_type reset(const recurse& r) const { + requestor = std::addressof(r.get_recursed()); + return exit_recursed_scope_type(this); + } + void operator()() const { + (*requestor)(); + } + }; + recursed_scope_type recursed_scope; + public: typedef typename composite_subscription::weak_subscription weak_subscription; typedef typename composite_subscription::shared_subscription shared_subscription; @@ -215,6 +314,17 @@ public: return schedulable(composite_subscription::empty(), sc, action::empty()); } + inline auto set_recursed(const recurse& r) const + -> decltype(recursed_scope.reset(r)) { + return recursed_scope.reset(r); + } + + // recursed + // + inline void operator()() const { + recursed_scope(); + } + // composite_subscription // inline bool is_subscribed() const { @@ -241,9 +351,6 @@ public: inline clock_type::time_point now() const { return controller.now(); } - inline bool is_tail_recursion_allowed() const { - return controller.is_tail_recursion_allowed(); - } inline void schedule() const { controller.schedule(*this); } @@ -259,12 +366,12 @@ public: inline action_duration::type get_duration() const { return activity.get_duration(); } - inline void operator()() const { + inline void operator()(const schedulable& scbl, const recurse& r) const { if (!is_subscribed()) { abort(); } detacher protect(this); - activity(*this); + activity(scbl, r); protect.that = nullptr; } }; @@ -288,7 +395,7 @@ class action_type typedef action_type this_type; public: - typedef std::function function_type; + typedef std::function function_type; private: action_duration::type d; @@ -309,11 +416,11 @@ public: return d; } - inline schedulable operator()(const schedulable& s) { - if (f) { - return f(s); + inline void operator()(const schedulable& s, const recurse& r) { + if (!f) { + abort(); } - return schedulable::empty(make_scheduler()); + f(s, r); } }; @@ -324,13 +431,10 @@ inline action_duration::type action::get_duration() const { return inner->get_duration(); } -inline void action::operator()(const schedulable& s) const { - auto next = (*inner)(s); - if (next.is_subscribed()) { - next.schedule(); - } +inline void action::operator()(const schedulable& s, const recurse& r) const { + (*inner)(s, r); } - + //static RXCPP_SELECT_ANY detail::action_ptr action::shared_empty = detail::action_ptr(new detail::action_type()); @@ -346,14 +450,18 @@ inline action make_action(F&& f, action_duration::type d = action_duration::runs d, // tail-recurse inside of the virtual function call // until a new action, lifetime or scheduler is returned - [fn](const schedulable& s) { - auto next = s; - auto last = s; - while (next.is_subscribed() && last == next && next.get_scheduler().is_tail_recursion_allowed()) { - last = next; - next = fn(next); + [fn](const schedulable& s, const recurse& r) { + auto scope = s.set_recursed(r); + while (s.is_subscribed()) { + r.reset(); + fn(s); + if (!r.is_allowed() || !r.is_requested()) { + if (r.is_requested()) { + s.schedule(); + } + break; + } } - return next; })); } @@ -368,7 +476,7 @@ struct is_action_function template static not_void check(...); - static const bool value = std::is_same::type>(0)), schedulable>::value; + static const bool value = std::is_same::type>(0)), void>::value; }; struct tag_action_function_resolution diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index b6c8d6f..192bff4 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -313,15 +313,19 @@ RXCPP_SELECT_ANY std::shared_ptr composite_subs namespace detail { - struct tag_subscription_resolution +struct tag_subscription_resolution +{ + template + struct predicate { - template - struct predicate - { - static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; - }; - typedef composite_subscription default_type; + static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; }; + struct default_type { + inline operator composite_subscription() const { + return composite_subscription(); + } + }; +}; } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index f5f2b85..72a8ab7 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -37,6 +37,7 @@ private: public: struct current_thread_queue_type { scheduler sc; + recursion r; queue_item_time queue; }; @@ -51,6 +52,9 @@ public: static scheduler get_scheduler() { return !!current_thread_queue() ? current_thread_queue()->sc : scheduler(); } + static recursion& get_recursion() { + return current_thread_queue()->r; + } static bool empty() { if (!current_thread_queue()) { abort(); @@ -64,19 +68,27 @@ public: return current_thread_queue()->queue.top(); } static void pop() { - if (!current_thread_queue()) { + auto state = current_thread_queue(); + if (!state) { abort(); } - current_thread_queue()->queue.pop(); + state->queue.pop(); + if (state->queue.empty()) { + // allow recursion + state->r.reset(true); + } } static void push(item_type item) { - if (!current_thread_queue()) { + auto state = current_thread_queue(); + if (!state) { abort(); } if (!item.what.is_subscribed()) { return; } - current_thread_queue()->queue.push(std::move(item)); + state->queue.push(std::move(item)); + // disallow recursion + state->r.reset(false); } static scheduler ensure(scheduler sc) { if (!!current_thread_queue()) { @@ -139,10 +151,6 @@ private: return clock_type::now(); } - inline bool is_tail_recursion_allowed() const { - return queue::empty(); - } - virtual void schedule(const schedulable& scbl) const { queue::push(queue::item_type(now(), scbl)); } @@ -204,6 +212,8 @@ public: queue::push(queue::item_type(when, scbl)); + const auto& recursor = queue::get_recursion().get_recurse(); + // loop until queue is empty for ( auto when = queue::top().when; @@ -215,9 +225,7 @@ public: queue::pop(); - if (what.is_subscribed()) { - what.get_action()(what); - } + what(what, recursor); if (queue::empty()) { break; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 4d0ab00..e832b52 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -116,15 +116,12 @@ public: schedule_absolute(created, make_action([createSrc, state](const schedulable& scbl) { state->source.reset(new typename state_type::source_type(createSrc())); - return schedulable::empty(scbl.get_scheduler()); })); schedule_absolute(subscribed, make_action([state](const schedulable& scbl) { state->source->subscribe(state->o); - return schedulable::empty(scbl.get_scheduler()); })); schedule_absolute(unsubscribed, make_action([state](const schedulable& scbl) { state->o.unsubscribe(); - return schedulable::empty(scbl.get_scheduler()); })); start(); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index 169bad1..82f426d 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -82,6 +82,8 @@ public: { if (!isenabled) { isenabled = true; + rxsc::recursion r; + r.reset(false); while (!empty() && isenabled) { auto next = top(); pop(); @@ -89,7 +91,7 @@ public: if (next.when > clock_now) { clock_now = next.when; } - next.what.get_action()(next.what); + next.what(next.what, r.get_recurse()); } else { isenabled = false; @@ -171,10 +173,6 @@ public: return to_time_point(clock_now); } - virtual bool is_tail_recursion_allowed() const { - return false; - } - virtual void schedule(const schedulable& scbl) const { schedule_absolute(clock_now, scbl.get_action()); } @@ -250,11 +248,12 @@ protected: auto run = make_schedulable( scheduler(this->shared_from_this()), [a](const schedulable& scbl) { + rxsc::recursion r; + r.reset(false); if (scbl.is_subscribed()) { scbl.unsubscribe(); // unsubscribe() run, not a; - a(scbl); + a(scbl, r.get_recurse()); } - return schedulable::empty(scbl.get_scheduler()); }); queue.push(item_type(when, run)); } diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index d7514c1..de4b753 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -34,14 +34,14 @@ struct range : public source_base template void on_subscribe(Subscriber o) { auto state = std::make_shared(init); - schedule(state->sc, o.get_subscription(), [=](rxsc::schedulable scbl){ + schedule(state->sc, o.get_subscription(), [=](const rxsc::schedulable& self){ if (state->remaining == 0) { o.on_completed(); // o is unsubscribed } if (!o.is_subscribed()) { // terminate loop - return scbl; + return; } // send next value @@ -50,7 +50,7 @@ struct range : public source_base state->next = static_cast(state->step + state->next); // tail recurse this same action to continue loop - return scbl; + self(); }); } }; diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index bac779b..197bc33 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -185,27 +185,27 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ auto o = s.get_subscriber(); sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ - s = rxsub::subject(); o = s.get_subscriber(); scbl.unsubscribe(); return scbl;}); + s = rxsub::subject(); o = s.get_subscriber();}); sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ - xs.subscribe(o); scbl.unsubscribe(); return scbl;}); + xs.subscribe(o);}); sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ - o.unsubscribe(); scbl.unsubscribe(); return scbl;}); + o.unsubscribe();}); sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results1); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results1);}); sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results2); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results2);}); sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results3); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results3);}); sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ - results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results1.unsubscribe();}); sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ - results2.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results2.unsubscribe();}); sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ - results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results1.unsubscribe();}); sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ - results3.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results3.unsubscribe();}); sc->start(); @@ -278,27 +278,27 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ auto o = s.get_subscriber(); sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ - s = rxsub::subject(); o = s.get_subscriber(); scbl.unsubscribe(); return scbl;}); + s = rxsub::subject(); o = s.get_subscriber();}); sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ - xs.subscribe(o); scbl.unsubscribe(); return scbl;}); + xs.subscribe(o);}); sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ - o.unsubscribe(); scbl.unsubscribe(); return scbl;}); + o.unsubscribe();}); sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results1); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results1);}); sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results2); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results2);}); sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results3); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results3);}); sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ - results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results1.unsubscribe();}); sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ - results2.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results2.unsubscribe();}); sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ - results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results1.unsubscribe();}); sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ - results3.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results3.unsubscribe();}); sc->start(); @@ -374,27 +374,27 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ auto o = s.get_subscriber(); sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ - s = rxsub::subject(); o = s.get_subscriber(); scbl.unsubscribe(); return scbl;}); + s = rxsub::subject(); o = s.get_subscriber();}); sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ - xs.subscribe(o); scbl.unsubscribe(); return scbl;}); + xs.subscribe(o);}); sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ - o.unsubscribe(); scbl.unsubscribe(); return scbl;}); + o.unsubscribe();}); sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results1); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results1);}); sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results2); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results2);}); sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ - s.get_observable().subscribe(results3); scbl.unsubscribe(); return scbl;}); + s.get_observable().subscribe(results3);}); sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ - results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results1.unsubscribe();}); sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ - results2.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results2.unsubscribe();}); sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ - results1.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results1.unsubscribe();}); sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ - results3.unsubscribe(); scbl.unsubscribe(); return scbl;}); + results3.unsubscribe();}); sc->start(); -- GitLab From 5b259eea6f184a37e1e9d1e308417c82ebbcc8f2 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 23 Mar 2014 19:50:12 -0700 Subject: [PATCH 232/782] added some comments and variadic subscribe --- Rx/v2/src/rxcpp/rx-observable.hpp | 96 ++++++++++++++++++++++++++++++- 1 file changed, 95 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 6a57bf4..b81fa5d 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -166,12 +166,14 @@ private: } }; + // make sure to let current_thread take ownership of the thread as early as possible. if (rxsc::current_thread::is_schedule_required()) { auto sc = rxsc::make_current_thread(); schedule(sc, [=](const rxsc::schedulable& scbl) { safe_subscribe(); }); } else { + // current_thread already owns this thread. safe_subscribe(); } @@ -215,48 +217,129 @@ public: #endif // - // performs type-forgetting conversion + // performs type-forgetting conversion to a new observable // observable as_dynamic() { return *this; } +#if RXCPP_USE_VARIADIC_TEMPLATES + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // + template + auto subscribe(Arg0&& a0, ArgN&&... an) const + -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...))) { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...)); + } +#else + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // template auto subscribe(Arg0&& a0) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0)))) { return detail_subscribe(make_subscriber(std::forward(a0))); } + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // template auto subscribe(Arg0&& a0, Arg1&& a1) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1))); } + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2))); } + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } + // + // subscribe will cause this observable to emit values to the provided subscriber. + // callers must provide enough arguments to make a subscriber. + // overrides are supported. thus + // subscribe(thesubscriber, composite_subscription()) + // will take thesubscriber.get_observer() and the provided + // subscription and subscribe to the new subscriber. + // the on_next, on_error, on_completed methods can be supplied instead of an observer + // if a subscription or subscriber is not provided then a new subscription will be created. + // template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } +#endif + // + // for each item from this observable use Predicate to select which items to emit from the new observable that is returned. + // template auto filter(Predicate&& p) const -> observable> { @@ -264,6 +347,9 @@ public: rxo::detail::filter(*this, std::forward(p))); } + // + // for each item from this observable use Selector to produce an item to emit from the new observable that is returned. + // template auto map(Selector&& s) const -> observable::value_type, rxo::detail::map> { @@ -271,6 +357,10 @@ public: rxo::detail::map(*this, std::forward(s))); } + // + // for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. + // for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. + // template auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const -> observable::value_type, rxo::detail::flat_map> { @@ -278,6 +368,10 @@ public: rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); } + // + // takes any function that will take this observable and produce a result value. + // this is intended to allow externally defined operators to be connected into the expression. + // template auto op(OperatorFactory&& of) const -> decltype(of(*(const this_type*)nullptr)) { -- GitLab From 81c3ea8bd75adeab64f64ece3754fbfe2e84e777 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 23 Mar 2014 21:12:57 -0700 Subject: [PATCH 233/782] add some comments an clean up test structure --- Rx/v2/src/rxcpp/rx-observable.hpp | 178 ++++----- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 347 +++++++++++------- Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 12 - Rx/v2/test/operators/filter.cpp | 313 ++++++++-------- Rx/v2/test/operators/flat_map.cpp | 280 +++++++------- Rx/v2/test/operators/map.cpp | 27 +- Rx/v2/test/subjects/subject.cpp | 247 +++++++------ Rx/v2/test/subscriptions/observer.cpp | 18 +- 8 files changed, 761 insertions(+), 661 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index b81fa5d..c062ae2 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -198,12 +198,12 @@ public: { } - // implicit conversion between observables of the same value_type + /// implicit conversion between observables of the same value_type template observable(const observable& o) : source_operator(o.source_operator) {} - // implicit conversion between observables of the same value_type + /// implicit conversion between observables of the same value_type template observable(observable&& o) : source_operator(std::move(o.source_operator)) @@ -216,120 +216,120 @@ public: } #endif - // - // performs type-forgetting conversion to a new observable - // + /// + /// performs type-forgetting conversion to a new observable + /// observable as_dynamic() { return *this; } #if RXCPP_USE_VARIADIC_TEMPLATES - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0, ArgN&&... an) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...)); } #else - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0)))) { return detail_subscribe(make_subscriber(std::forward(a0))); } - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0, Arg1&& a1) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1))); } - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2))); } - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } - // - // subscribe will cause this observable to emit values to the provided subscriber. - // callers must provide enough arguments to make a subscriber. - // overrides are supported. thus - // subscribe(thesubscriber, composite_subscription()) - // will take thesubscriber.get_observer() and the provided - // subscription and subscribe to the new subscriber. - // the on_next, on_error, on_completed methods can be supplied instead of an observer - // if a subscription or subscriber is not provided then a new subscription will be created. - // + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// template auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) const -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { @@ -337,9 +337,9 @@ public: } #endif - // - // for each item from this observable use Predicate to select which items to emit from the new observable that is returned. - // + /// filter (AKA Where) -> + /// for each item from this observable use Predicate to select which items to emit from the new observable that is returned. + /// template auto filter(Predicate&& p) const -> observable> { @@ -347,9 +347,9 @@ public: rxo::detail::filter(*this, std::forward(p))); } - // - // for each item from this observable use Selector to produce an item to emit from the new observable that is returned. - // + /// map (AKA Select) -> + /// for each item from this observable use Selector to produce an item to emit from the new observable that is returned. + /// template auto map(Selector&& s) const -> observable::value_type, rxo::detail::map> { @@ -357,10 +357,10 @@ public: rxo::detail::map(*this, std::forward(s))); } - // - // for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. - // for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. - // + /// flat_map (AKA SelectMany) -> + /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. + /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. + /// template auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const -> observable::value_type, rxo::detail::flat_map> { @@ -368,10 +368,10 @@ public: rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); } - // - // takes any function that will take this observable and produce a result value. - // this is intended to allow externally defined operators to be connected into the expression. - // + /// + /// takes any function that will take this observable and produce a result value. + /// this is intended to allow externally defined operators to be connected into the expression. + /// template auto op(OperatorFactory&& of) const -> decltype(of(*(const this_type*)nullptr)) { diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index e832b52..22e3897 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -11,58 +11,14 @@ namespace rxcpp { namespace schedulers { -class test : public virtual_time +namespace detail { + +class test_type : public virtual_time { public: typedef virtual_time base; typedef base::clock_type clock_type; - typedef std::shared_ptr shared; - - static const long created_time = 100; - static const long subscribed_time = 200; - static const long unsubscribed_time = 1000; - - template - struct messages - { - typedef typename rxn::notification notification_type; - typedef rxn::recorded recorded_type; - - struct on_next_factory - { - recorded_type operator()(long ticks, T value) const { - return recorded_type(ticks, notification_type::on_next(value)); - } - }; - struct on_completed_factory - { - recorded_type operator()(long ticks) const { - return recorded_type(ticks, notification_type::on_completed()); - } - }; - struct on_error_factory - { - template - recorded_type operator()(long ticks, Exception&& e) const { - return recorded_type(ticks, notification_type::on_error(std::forward(e))); - } - }; - - static const on_next_factory on_next; - static const on_completed_factory on_completed; - static const on_error_factory on_error; - - struct subscribe_factory - { - rxn::subscription operator()(long subscribe, long unsubscribe) const { - return rxn::subscription(subscribe, unsubscribe); - } - }; - static const subscribe_factory subscribe; - - private: - ~messages(); - }; + typedef std::shared_ptr shared; using base::schedule_absolute; using base::schedule_relative; @@ -92,95 +48,16 @@ public: using base::start; - template - auto start(F&& createSource, long created, long subscribed, long unsubscribed) const - -> subscriber> - { - typename std::decay::type createSrc = std::forward(createSource); - - struct state_type - : public std::enable_shared_from_this - { - typedef decltype(std::forward(createSrc)()) source_type; - - std::unique_ptr source; - subscriber> o; - - explicit state_type(subscriber> o) - : source() - , o(o) - { - } - }; - std::shared_ptr state(new state_type(this->make_subscriber())); - - schedule_absolute(created, make_action([createSrc, state](const schedulable& scbl) { - state->source.reset(new typename state_type::source_type(createSrc())); - })); - schedule_absolute(subscribed, make_action([state](const schedulable& scbl) { - state->source->subscribe(state->o); - })); - schedule_absolute(unsubscribed, make_action([state](const schedulable& scbl) { - state->o.unsubscribe(); - })); - - start(); - - return state->o; - } - - template - auto start(F&& createSource, long unsubscribed) const - -> subscriber> - { - return start(std::forward(createSource), created_time, subscribed_time, unsubscribed); - } - - template - auto start(F&& createSource) const - -> subscriber> - { - return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); - } - template rxt::testable_observable make_hot_observable(std::vector>>> messages) const; - template - auto make_hot_observable(const T (&arr) [size]) const - -> decltype(make_hot_observable(std::vector())) { - return make_hot_observable(rxu::to_vector(arr)); - } - template rxt::testable_observable make_cold_observable(std::vector>>> messages) const; - template - auto make_cold_observable(const T (&arr) [size]) const - -> decltype(make_cold_observable(std::vector())) { - return make_cold_observable(rxu::to_vector(arr)); - } - template subscriber> make_subscriber() const; }; -template -//static -RXCPP_SELECT_ANY const typename test::messages::on_next_factory test::messages::on_next = test::messages::on_next_factory(); - -template -//static -RXCPP_SELECT_ANY const typename test::messages::on_completed_factory test::messages::on_completed = test::messages::on_completed_factory(); - -template -//static -RXCPP_SELECT_ANY const typename test::messages::on_error_factory test::messages::on_error = test::messages::on_error_factory(); - -template -//static -RXCPP_SELECT_ANY const typename test::messages::subscribe_factory test::messages::subscribe = test::messages::subscribe_factory(); - template class mock_observer : public rxt::detail::test_subject_base @@ -189,12 +66,12 @@ class mock_observer typedef rxn::recorded recorded_type; public: - mock_observer(typename test::shared sc) + mock_observer(typename test_type::shared sc) : sc(sc) { } - typename test::shared sc; + typename test_type::shared sc; std::vector m; virtual void on_subscribe(subscriber) const { @@ -210,13 +87,13 @@ public: }; template -subscriber> test::make_subscriber() const +subscriber> test_type::make_subscriber() const { typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - - std::shared_ptr> ts(new mock_observer(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())))); - + + std::shared_ptr> ts(new mock_observer(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())))); + return rxcpp::make_subscriber(rxt::testable_observer(ts, make_observer_dynamic( // on_next [ts](T value) @@ -243,21 +120,21 @@ class cold_observable : public rxt::detail::test_subject_base { typedef cold_observable this_type; - typename test::shared sc; + typename test_type::shared sc; typedef rxn::recorded::type> recorded_type; mutable std::vector mv; mutable std::vector sv; public: - cold_observable(typename test::shared sc, std::vector mv) + cold_observable(typename test_type::shared sc, std::vector mv) : sc(sc) , mv(std::move(mv)) { } template - cold_observable(typename test::shared sc, Iterator begin, Iterator end) + cold_observable(typename test_type::shared sc, Iterator begin, Iterator end) : scheduler(sc) , mv(begin, end) { @@ -292,9 +169,9 @@ public: }; template -rxt::testable_observable test::make_cold_observable(std::vector>>> messages) const +rxt::testable_observable test_type::make_cold_observable(std::vector>>> messages) const { - auto co = std::shared_ptr>(new cold_observable(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); + auto co = std::shared_ptr>(new cold_observable(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); return rxt::testable_observable(co); } @@ -303,7 +180,7 @@ class hot_observable : public rxt::detail::test_subject_base { typedef hot_observable this_type; - typename test::shared sc; + typename test_type::shared sc; typedef rxn::recorded::type> recorded_type; typedef subscriber observer_type; mutable std::vector mv; @@ -312,7 +189,7 @@ class hot_observable public: - hot_observable(typename test::shared sc, std::vector mv) + hot_observable(typename test_type::shared sc, std::vector mv) : sc(sc) , mv(mv) { @@ -349,10 +226,196 @@ public: }; template -rxt::testable_observable test::make_hot_observable(std::vector>>> messages) const +rxt::testable_observable test_type::make_hot_observable(std::vector>>> messages) const { return rxt::testable_observable(std::make_shared>( - std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); + std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); +} + +} + +class test +{ + detail::test_type::shared tester; +public: + + explicit test(detail::test_type::shared t) + : tester(std::move(t)) + { + } + + typedef detail::test_type::clock_type clock_type; + + static const long created_time = 100; + static const long subscribed_time = 200; + static const long unsubscribed_time = 1000; + + template + struct messages + { + typedef typename rxn::notification notification_type; + typedef rxn::recorded recorded_type; + + struct on_next_factory + { + recorded_type operator()(long ticks, T value) const { + return recorded_type(ticks, notification_type::on_next(value)); + } + }; + struct on_completed_factory + { + recorded_type operator()(long ticks) const { + return recorded_type(ticks, notification_type::on_completed()); + } + }; + struct on_error_factory + { + template + recorded_type operator()(long ticks, Exception&& e) const { + return recorded_type(ticks, notification_type::on_error(std::forward(e))); + } + }; + + static const on_next_factory on_next; + static const on_completed_factory on_completed; + static const on_error_factory on_error; + + struct subscribe_factory + { + rxn::subscription operator()(long subscribe, long unsubscribe) const { + return rxn::subscription(subscribe, unsubscribe); + } + }; + static const subscribe_factory subscribe; + + private: + ~messages(); + }; + + void schedule_absolute(long when, action a) const { + tester->schedule_absolute(when, std::move(a)); + } + + void schedule_relative(long when, action a) const { + tester->schedule_relative(when, std::move(a)); + } + + template + typename std::enable_if::type, action>::value, void>::type + schedule_absolute(long when, F f) const { + tester->schedule_absolute(when, make_action(f)); + } + + + template + typename std::enable_if::type, action>::value, void>::type + schedule_relative(long when, F f) const { + tester->schedule_relative(when, make_action(f)); + } + + template + auto start(F&& createSource, long created, long subscribed, long unsubscribed) const + -> subscriber> + { + typename std::decay::type createSrc = std::forward(createSource); + + struct state_type + : public std::enable_shared_from_this + { + typedef decltype(std::forward(createSrc)()) source_type; + + std::unique_ptr source; + subscriber> o; + + explicit state_type(subscriber> o) + : source() + , o(o) + { + } + }; + std::shared_ptr state(new state_type(this->make_subscriber())); + + schedule_absolute(created, make_action([createSrc, state](const schedulable& scbl) { + state->source.reset(new typename state_type::source_type(createSrc())); + })); + schedule_absolute(subscribed, make_action([state](const schedulable& scbl) { + state->source->subscribe(state->o); + })); + schedule_absolute(unsubscribed, make_action([state](const schedulable& scbl) { + state->o.unsubscribe(); + })); + + tester->start(); + + return state->o; + } + + template + auto start(F&& createSource, long unsubscribed) const + -> subscriber> + { + return start(std::forward(createSource), created_time, subscribed_time, unsubscribed); + } + + template + auto start(F&& createSource) const + -> subscriber> + { + return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); + } + + void start() const { + tester->start(); + } + + template + rxt::testable_observable make_hot_observable(std::vector>>> messages) const{ + return tester->make_hot_observable(std::move(messages)); + } + + template + auto make_hot_observable(const T (&arr) [size]) const + -> decltype(tester->make_hot_observable(std::vector())) { + return tester->make_hot_observable(rxu::to_vector(arr)); + } + + template + rxt::testable_observable make_cold_observable(std::vector>>> messages) const { + return tester->make_cold_observable(std::move(messages)); + } + + template + auto make_cold_observable(const T (&arr) [size]) const + -> decltype(tester->make_cold_observable(std::vector())) { + return tester->make_cold_observable(rxu::to_vector(arr)); + } + + template + subscriber> make_subscriber() const { + return tester->make_subscriber(); + } +}; + +template +//static +RXCPP_SELECT_ANY const typename test::messages::on_next_factory test::messages::on_next = test::messages::on_next_factory(); + +template +//static +RXCPP_SELECT_ANY const typename test::messages::on_completed_factory test::messages::on_completed = test::messages::on_completed_factory(); + +template +//static +RXCPP_SELECT_ANY const typename test::messages::on_error_factory test::messages::on_error = test::messages::on_error_factory(); + +template +//static +RXCPP_SELECT_ANY const typename test::messages::subscribe_factory test::messages::subscribe = test::messages::subscribe_factory(); + + + +inline test make_test() { + return test(std::make_shared()); } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index 82f426d..974e6d6 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -58,23 +58,11 @@ protected: public: virtual void schedule_absolute(absolute, action) const =0; - template - typename std::enable_if::type, action>::value, void>::type - schedule_absolute(absolute when, F f) const { - schedule_absolute(when, make_action(f)); - } - virtual void schedule_relative(relative when, action a) const { auto at = add(clock_now, when); return schedule_absolute(at, std::move(a)); } - template - typename std::enable_if::type, action>::value, void>::type - schedule_relative(relative when, F f) const { - schedule_relative(when, make_action(f)); - } - bool is_enabled() const {return isenabled;} absolute clock() const {return clock_now;} diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index f68fb4c..ac101ef 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -30,32 +30,38 @@ bool IsPrime(int x) SCENARIO("filter stops on completion", "[filter][operators]"){ GIVEN("a test hot observable of ints"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; long invoked = 0; - m::recorded_type messages[] = { - m::on_next(110, 1), - m::on_next(180, 2), - m::on_next(230, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(380, 6), - m::on_next(390, 7), - m::on_next(450, 8), - m::on_next(470, 9), - m::on_next(560, 10), - m::on_next(580, 11), - m::on_completed(600), - m::on_next(610, 12), - m::on_error(620, std::runtime_error("error in unsubscribed stream")), - m::on_completed(630) + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600), + on_next(610, 12), + on_error(620, std::runtime_error("error in unsubscribed stream")), + on_completed(630) }; - auto xs = sc->make_hot_observable(messages); + auto xs = sc.make_hot_observable(messages); WHEN("filtered to ints that are primes"){ - auto res = sc->start( + auto res = sc.start( [&xs, &invoked]() { #if 0 && RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -81,12 +87,12 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ } ); THEN("the output only contains primes"){ - m::recorded_type items[] = { - m::on_next(230, 3), - m::on_next(340, 5), - m::on_next(390, 7), - m::on_next(580, 11), - m::on_completed(600) + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7), + on_next(580, 11), + on_completed(600) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -94,8 +100,8 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ } THEN("there was one subscription and one unsubscription"){ - rxn::subscription items[] = { - m::subscribe(200, 600) + life items[] = { + subscribe(200, 600) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -112,30 +118,35 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; long invoked = 0; - m::recorded_type messages[] = { - m::on_next(110, 1), - m::on_next(180, 2), - m::on_next(230, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(380, 6), - m::on_next(390, 7), - m::on_next(450, 8), - m::on_next(470, 9), - m::on_next(560, 10), - m::on_next(580, 11), - m::on_completed(600) + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600) }; - auto xs = sc->make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); WHEN("filtered to ints that are primes"){ - auto res = sc->start( + auto res = sc.start( [&xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -159,10 +170,10 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ ); THEN("the output only contains primes that arrived before disposal"){ - m::recorded_type items[] = { - m::on_next(230, 3), - m::on_next(340, 5), - m::on_next(390, 7) + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -170,8 +181,8 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ } THEN("there was one subscription and one unsubscription"){ - rxn::subscription items[] = { - m::subscribe(200, 400) + life items[] = { + subscribe(200, 400) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -187,39 +198,41 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ SCENARIO("filter stops on error", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; long invoked = 0; std::runtime_error ex("filter on_error from source"); - auto xs = sc->make_hot_observable( - [ex]() { - m::recorded_type messages[] = { - m::on_next(110, 1), - m::on_next(180, 2), - m::on_next(230, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(380, 6), - m::on_next(390, 7), - m::on_next(450, 8), - m::on_next(470, 9), - m::on_next(560, 10), - m::on_next(580, 11), - m::on_error(600, ex), - m::on_next(610, 12), - m::on_error(620, std::runtime_error("error in unsubscribed stream")), - m::on_completed(630) - }; - return rxu::to_vector(messages); - }() - ); + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_error(600, ex), + on_next(610, 12), + on_error(620, std::runtime_error("error in unsubscribed stream")), + on_completed(630) + }; + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); WHEN("filtered to ints that are primes"){ - auto res = sc->start( + auto res = sc.start( [xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -242,12 +255,12 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ ); THEN("the output only contains primes"){ - m::recorded_type items[] = { - m::on_next(230, 3), - m::on_next(340, 5), - m::on_next(390, 7), - m::on_next(580, 11), - m::on_error(600, ex), + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7), + on_next(580, 11), + on_error(600, ex), }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -255,8 +268,8 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ } THEN("there was one subscription and one unsubscription"){ - rxn::subscription items[] = { - m::subscribe(200, 600) + life items[] = { + subscribe(200, 600) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -272,39 +285,41 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; long invoked = 0; std::runtime_error ex("filter predicate error"); - auto xs = sc->make_hot_observable( - []() { - m::recorded_type messages[] = { - m::on_next(110, 1), - m::on_next(180, 2), - m::on_next(230, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(380, 6), - m::on_next(390, 7), - m::on_next(450, 8), - m::on_next(470, 9), - m::on_next(560, 10), - m::on_next(580, 11), - m::on_completed(600), - m::on_next(610, 12), - m::on_error(620, std::runtime_error("error in unsubscribed stream")), - m::on_completed(630) - }; - return rxu::to_vector(messages); - }() - ); + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600), + on_next(610, 12), + on_error(620, std::runtime_error("error in unsubscribed stream")), + on_completed(630) + }; + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); WHEN("filtered to ints that are primes"){ - auto res = sc->start( + auto res = sc.start( [ex, xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -333,10 +348,10 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ ); THEN("the output only contains primes"){ - m::recorded_type items[] = { - m::on_next(230, 3), - m::on_next(340, 5), - m::on_error(380, ex) + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_error(380, ex) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -344,8 +359,8 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ } THEN("there was one subscription and one unsubscription"){ - rxn::subscription items[] = { - m::subscribe(200, 380) + life items[] = { + subscribe(200, 380) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -361,41 +376,43 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; long invoked = 0; - auto xs = sc->make_hot_observable( - []() { - m::recorded_type messages[] = { - m::on_next(110, 1), - m::on_next(180, 2), - m::on_next(230, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(380, 6), - m::on_next(390, 7), - m::on_next(450, 8), - m::on_next(470, 9), - m::on_next(560, 10), - m::on_next(580, 11), - m::on_completed(600), - m::on_next(610, 12), - m::on_error(620, std::exception()), - m::on_completed(630) - }; - return rxu::to_vector(messages); - }() - ); + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600), + on_next(610, 12), + on_error(620, std::exception()), + on_completed(630) + }; + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); - auto res = sc->make_subscriber(); + auto res = sc.make_subscriber(); rx::observable> ys; WHEN("filtered to ints that are primes"){ - sc->schedule_absolute(rxsc::test::created_time, + sc.schedule_absolute(rxsc::test::created_time, [&invoked, &res, &ys, &xs](const rxsc::schedulable& scbl) { #if RXCPP_USE_OBSERVABLE_MEMBERS ys = xs @@ -414,29 +431,23 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") return IsPrime(x); }); #endif - scbl.unsubscribe(); - return scbl; }); - sc->schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl) { + sc.schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl) { ys.subscribe(res); - scbl.unsubscribe(); - return scbl; }); - sc->schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl) { + sc.schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl) { res.unsubscribe(); - scbl.unsubscribe(); - return scbl; }); - sc->start(); + sc.start(); THEN("the output only contains primes"){ - m::recorded_type items[] = { - m::on_next(230, 3), - m::on_next(340, 5), - m::on_next(390, 7) + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -444,8 +455,8 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") } THEN("there was one subscription and one unsubscription"){ - rxn::subscription items[] = { - m::subscribe(200, 450) + life items[] = { + subscribe(200, 450) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index ffceaf4..1fff6a4 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -14,31 +14,42 @@ namespace rxt=rxcpp::test; SCENARIO("flat_map completes", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; typedef rxsc::test::messages ms; + typedef rxn::subscription life; - m::recorded_type int_messages[] = { - m::on_next(100, 4), - m::on_next(200, 2), - m::on_next(300, 3), - m::on_next(400, 1), - m::on_completed(500) + typedef m::recorded_type irecord; + auto ion_next = m::on_next; + auto ion_completed = m::on_completed; + auto isubscribe = m::subscribe; + + typedef ms::recorded_type srecord; + auto son_next = ms::on_next; + auto son_completed = ms::on_completed; + auto ssubscribe = ms::subscribe; + + irecord int_messages[] = { + ion_next(100, 4), + ion_next(200, 2), + ion_next(300, 3), + ion_next(400, 1), + ion_completed(500) }; - auto xs = sc->make_cold_observable(int_messages); - - ms::recorded_type string_messages[] = { - ms::on_next(50, "foo"), - ms::on_next(100, "bar"), - ms::on_next(150, "baz"), - ms::on_next(200, "qux"), - ms::on_completed(250) + auto xs = sc.make_cold_observable(int_messages); + + srecord string_messages[] = { + son_next(50, "foo"), + son_next(100, "bar"), + son_next(150, "baz"), + son_next(200, "qux"), + son_completed(250) }; - auto ys = sc->make_cold_observable(string_messages); + auto ys = sc.make_cold_observable(string_messages); WHEN("each int is mapped to the strings"){ - auto res = sc->start( + auto res = sc.start( [&]() { return xs .flat_map( @@ -52,24 +63,24 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - ms::recorded_type items[] = { - ms::on_next(350, "foo"), - ms::on_next(400, "bar"), - ms::on_next(450, "baz"), - ms::on_next(450, "foo"), - ms::on_next(500, "qux"), - ms::on_next(500, "bar"), - ms::on_next(550, "baz"), - ms::on_next(550, "foo"), - ms::on_next(600, "qux"), - ms::on_next(600, "bar"), - ms::on_next(650, "baz"), - ms::on_next(650, "foo"), - ms::on_next(700, "bar"), - ms::on_next(700, "qux"), - ms::on_next(750, "baz"), - ms::on_next(800, "qux"), - ms::on_completed(850) + srecord items[] = { + son_next(350, "foo"), + son_next(400, "bar"), + son_next(450, "baz"), + son_next(450, "foo"), + son_next(500, "qux"), + son_next(500, "bar"), + son_next(550, "baz"), + son_next(550, "foo"), + son_next(600, "qux"), + son_next(600, "bar"), + son_next(650, "baz"), + son_next(650, "foo"), + son_next(700, "bar"), + son_next(700, "qux"), + son_next(750, "baz"), + son_next(800, "qux"), + son_completed(850) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -77,8 +88,8 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ } THEN("there was one subscription and one unsubscription to the ints"){ - rxn::subscription items[] = { - m::subscribe(200, 700) + life items[] = { + isubscribe(200, 700) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -86,11 +97,11 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ } THEN("there were four subscription and unsubscription to the strings"){ - rxn::subscription items[] = { - ms::subscribe(300, 550), - ms::subscribe(400, 650), - ms::subscribe(500, 750), - ms::subscribe(600, 850) + life items[] = { + ssubscribe(300, 550), + ssubscribe(400, 650), + ssubscribe(500, 750), + ssubscribe(600, 850) }; auto required = rxu::to_vector(items); auto actual = ys.subscriptions(); @@ -103,32 +114,42 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; typedef rxsc::test::messages ms; + typedef rxn::subscription life; + + typedef m::recorded_type irecord; + auto ion_next = m::on_next; + auto isubscribe = m::subscribe; - m::recorded_type int_messages[] = { - m::on_next(100, 4), - m::on_next(200, 2), - m::on_next(300, 3), - m::on_next(400, 1), - m::on_next(500, 5), - m::on_next(700, 0) + typedef ms::recorded_type srecord; + auto son_next = ms::on_next; + auto son_completed = ms::on_completed; + auto ssubscribe = ms::subscribe; + + irecord int_messages[] = { + ion_next(100, 4), + ion_next(200, 2), + ion_next(300, 3), + ion_next(400, 1), + ion_next(500, 5), + ion_next(700, 0) }; - auto xs = sc->make_cold_observable(int_messages); - - ms::recorded_type string_messages[] = { - ms::on_next(50, "foo"), - ms::on_next(100, "bar"), - ms::on_next(150, "baz"), - ms::on_next(200, "qux"), - ms::on_completed(250) + auto xs = sc.make_cold_observable(int_messages); + + srecord string_messages[] = { + son_next(50, "foo"), + son_next(100, "bar"), + son_next(150, "baz"), + son_next(200, "qux"), + son_completed(250) }; - auto ys = sc->make_cold_observable(string_messages); + auto ys = sc.make_cold_observable(string_messages); WHEN("each int is mapped to the strings"){ - auto res = sc->start( + auto res = sc.start( [&]() { return xs .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) @@ -138,28 +159,28 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - ms::recorded_type items[] = { - ms::on_next(350, "foo"), - ms::on_next(400, "bar"), - ms::on_next(450, "baz"), - ms::on_next(450, "foo"), - ms::on_next(500, "bar"), - ms::on_next(500, "qux"), - ms::on_next(550, "baz"), - ms::on_next(550, "foo"), - ms::on_next(600, "bar"), - ms::on_next(600, "qux"), - ms::on_next(650, "baz"), - ms::on_next(650, "foo"), - ms::on_next(700, "bar"), - ms::on_next(700, "qux"), - ms::on_next(750, "baz"), - ms::on_next(750, "foo"), - ms::on_next(800, "bar"), - ms::on_next(800, "qux"), - ms::on_next(850, "baz"), - ms::on_next(900, "qux"), - ms::on_next(950, "foo") + srecord items[] = { + son_next(350, "foo"), + son_next(400, "bar"), + son_next(450, "baz"), + son_next(450, "foo"), + son_next(500, "bar"), + son_next(500, "qux"), + son_next(550, "baz"), + son_next(550, "foo"), + son_next(600, "bar"), + son_next(600, "qux"), + son_next(650, "baz"), + son_next(650, "foo"), + son_next(700, "bar"), + son_next(700, "qux"), + son_next(750, "baz"), + son_next(750, "foo"), + son_next(800, "bar"), + son_next(800, "qux"), + son_next(850, "baz"), + son_next(900, "qux"), + son_next(950, "foo") }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -167,8 +188,8 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ } THEN("there was one subscription and one unsubscription to the ints"){ - rxn::subscription items[] = { - m::subscribe(200, 1000) + life items[] = { + isubscribe(200, 1000) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -176,13 +197,13 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ } THEN("there were four subscription and unsubscription to the strings"){ - rxn::subscription items[] = { - ms::subscribe(300, 550), - ms::subscribe(400, 650), - ms::subscribe(500, 750), - ms::subscribe(600, 850), - ms::subscribe(700, 950), - ms::subscribe(900, 1000) + life items[] = { + ssubscribe(300, 550), + ssubscribe(400, 650), + ssubscribe(500, 750), + ssubscribe(600, 850), + ssubscribe(700, 950), + ssubscribe(900, 1000) }; auto required = rxu::to_vector(items); auto actual = ys.subscriptions(); @@ -194,33 +215,44 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; typedef rxsc::test::messages ms; + typedef rxn::subscription life; + + typedef m::recorded_type irecord; + auto ion_next = m::on_next; + auto ion_completed = m::on_completed; + auto isubscribe = m::subscribe; + + typedef ms::recorded_type srecord; + auto son_next = ms::on_next; + auto son_error = ms::on_error; + auto ssubscribe = ms::subscribe; - m::recorded_type int_messages[] = { - m::on_next(100, 4), - m::on_next(200, 2), - m::on_next(300, 3), - m::on_next(400, 1), - m::on_completed(500) + irecord int_messages[] = { + ion_next(100, 4), + ion_next(200, 2), + ion_next(300, 3), + ion_next(400, 1), + ion_completed(500) }; - auto xs = sc->make_cold_observable(int_messages); + auto xs = sc.make_cold_observable(int_messages); std::runtime_error ex("filter on_error from inner source"); - ms::recorded_type string_messages[] = { - ms::on_next(55, "foo"), - ms::on_next(104, "bar"), - ms::on_next(153, "baz"), - ms::on_next(202, "qux"), - ms::on_error(301, ex) + srecord string_messages[] = { + son_next(55, "foo"), + son_next(104, "bar"), + son_next(153, "baz"), + son_next(202, "qux"), + son_error(301, ex) }; - auto ys = sc->make_cold_observable(string_messages); + auto ys = sc.make_cold_observable(string_messages); WHEN("each int is mapped to the strings"){ - auto res = sc->start( + auto res = sc.start( [&]() { return xs .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) @@ -230,16 +262,16 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - ms::recorded_type items[] = { - ms::on_next(355, "foo"), - ms::on_next(404, "bar"), - ms::on_next(453, "baz"), - ms::on_next(455, "foo"), - ms::on_next(502, "qux"), - ms::on_next(504, "bar"), - ms::on_next(553, "baz"), - ms::on_next(555, "foo"), - ms::on_error(601, ex) + srecord items[] = { + son_next(355, "foo"), + son_next(404, "bar"), + son_next(453, "baz"), + son_next(455, "foo"), + son_next(502, "qux"), + son_next(504, "bar"), + son_next(553, "baz"), + son_next(555, "foo"), + son_error(601, ex) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -247,8 +279,8 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ } THEN("there was one subscription and one unsubscription to the ints"){ - rxn::subscription items[] = { - m::subscribe(200, 601) + life items[] = { + isubscribe(200, 601) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); @@ -256,11 +288,11 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ } THEN("there were four subscription and unsubscription to the strings"){ - rxn::subscription items[] = { - ms::subscribe(300, 601), - ms::subscribe(400, 601), - ms::subscribe(500, 601), - ms::subscribe(600, 601) + life items[] = { + ssubscribe(300, 601), + ssubscribe(400, 601), + ssubscribe(500, 601), + ssubscribe(600, 601) }; auto required = rxu::to_vector(items); auto actual = ys.subscriptions(); diff --git a/Rx/v2/test/operators/map.cpp b/Rx/v2/test/operators/map.cpp index 61da39c..354fd24 100644 --- a/Rx/v2/test/operators/map.cpp +++ b/Rx/v2/test/operators/map.cpp @@ -15,15 +15,18 @@ namespace rxt=rxcpp::test; SCENARIO("map stops on completion", "[map][operators]"){ GIVEN("a test hot observable of ints"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; auto on_next = m::on_next; auto on_error = m::on_error; auto on_completed = m::on_completed; + auto subscribe = m::subscribe; long invoked = 0; - m::recorded_type messages[] = { + record messages[] = { on_next(180, 1), on_next(210, 2), on_next(240, 3), @@ -34,11 +37,11 @@ SCENARIO("map stops on completion", "[map][operators]"){ on_completed(420), on_error(430, std::runtime_error("error on unsubscribed stream")) }; - auto xs = sc->make_hot_observable(messages); + auto xs = sc.make_hot_observable(messages); WHEN("mapped to ints that are one larger"){ - auto res = sc->start( + auto res = sc.start( [xs, &invoked]() { return xs .map([&invoked](int x) { @@ -51,12 +54,12 @@ SCENARIO("map stops on completion", "[map][operators]"){ ); THEN("the output stops on completion"){ - m::recorded_type items[] = { - m::on_next(210, 3), - m::on_next(240, 4), - m::on_next(290, 5), - m::on_next(350, 6), - m::on_completed(400) + record items[] = { + on_next(210, 3), + on_next(240, 4), + on_next(290, 5), + on_next(350, 6), + on_completed(400) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -64,8 +67,8 @@ SCENARIO("map stops on completion", "[map][operators]"){ } THEN("there was one subscription and one unsubscription"){ - rxn::subscription items[] = { - m::subscribe(200, 400) + life items[] = { + subscribe(200, 400) }; auto required = rxu::to_vector(items); auto actual = xs.subscriptions(); diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 197bc33..06c2f49 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -153,67 +153,70 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; - - m::recorded_type messages[] = { - m::on_next(70, 1), - m::on_next(110, 2), - m::on_next(220, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(410, 6), - m::on_next(520, 7), - m::on_next(630, 8), - m::on_next(710, 9), - m::on_next(870, 10), - m::on_next(940, 11), - m::on_next(1020, 12) + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + + record messages[] = { + on_next(70, 1), + on_next(110, 2), + on_next(220, 3), + on_next(270, 4), + on_next(340, 5), + on_next(410, 6), + on_next(520, 7), + on_next(630, 8), + on_next(710, 9), + on_next(870, 10), + on_next(940, 11), + on_next(1020, 12) }; - auto xs = sc->make_hot_observable(messages); + auto xs = sc.make_hot_observable(messages); rxsub::subject s; - auto results1 = sc->make_subscriber(); + auto results1 = sc.make_subscriber(); - auto results2 = sc->make_subscriber(); + auto results2 = sc.make_subscriber(); - auto results3 = sc->make_subscriber(); + auto results3 = sc.make_subscriber(); WHEN("multicasting an infinite source"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ s = rxsub::subject(); o = s.get_subscriber();}); - sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ xs.subscribe(o);}); - sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ o.unsubscribe();}); - sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results1);}); - sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + sc.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results2);}); - sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + sc.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results3);}); - sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + sc.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ results2.unsubscribe();}); - sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + sc.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ results3.unsubscribe();}); - sc->start(); + sc.start(); THEN("result1 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(340, 5), - m::on_next(410, 6), - m::on_next(520, 7) + record items[] = { + on_next(340, 5), + on_next(410, 6), + on_next(520, 7) }; auto required = rxu::to_vector(items); auto actual = results1.get_observer().messages(); @@ -221,10 +224,10 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ } THEN("result2 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(410, 6), - m::on_next(520, 7), - m::on_next(630, 8) + record items[] = { + on_next(410, 6), + on_next(520, 7), + on_next(630, 8) }; auto required = rxu::to_vector(items); auto actual = results2.get_observer().messages(); @@ -232,8 +235,8 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ } THEN("result3 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(940, 11) + record items[] = { + on_next(940, 11) }; auto required = rxu::to_vector(items); auto actual = results3.get_observer().messages(); @@ -247,66 +250,71 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ SCENARIO("subject - finite source", "[subject][subjects]"){ GIVEN("a subject and an finite source"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; - - m::recorded_type messages[] = { - m::on_next(70, 1), - m::on_next(110, 2), - m::on_next(220, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(410, 6), - m::on_next(520, 7), - m::on_completed(630), - m::on_next(640, 9), - m::on_completed(650), - m::on_error(660, std::runtime_error("error on unsubscribed stream")) + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + + record messages[] = { + on_next(70, 1), + on_next(110, 2), + on_next(220, 3), + on_next(270, 4), + on_next(340, 5), + on_next(410, 6), + on_next(520, 7), + on_completed(630), + on_next(640, 9), + on_completed(650), + on_error(660, std::runtime_error("error on unsubscribed stream")) }; - auto xs = sc->make_hot_observable(messages); + auto xs = sc.make_hot_observable(messages); rxsub::subject s; - auto results1 = sc->make_subscriber(); + auto results1 = sc.make_subscriber(); - auto results2 = sc->make_subscriber(); + auto results2 = sc.make_subscriber(); - auto results3 = sc->make_subscriber(); + auto results3 = sc.make_subscriber(); WHEN("multicasting an infinite source"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ s = rxsub::subject(); o = s.get_subscriber();}); - sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ xs.subscribe(o);}); - sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ o.unsubscribe();}); - sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results1);}); - sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + sc.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results2);}); - sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + sc.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results3);}); - sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + sc.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ results2.unsubscribe();}); - sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + sc.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ results3.unsubscribe();}); - sc->start(); + sc.start(); THEN("result1 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(340, 5), - m::on_next(410, 6), - m::on_next(520, 7) + record items[] = { + on_next(340, 5), + on_next(410, 6), + on_next(520, 7) }; auto required = rxu::to_vector(items); auto actual = results1.get_observer().messages(); @@ -314,10 +322,10 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ } THEN("result2 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(410, 6), - m::on_next(520, 7), - m::on_completed(630) + record items[] = { + on_next(410, 6), + on_next(520, 7), + on_completed(630) }; auto required = rxu::to_vector(items); auto actual = results2.get_observer().messages(); @@ -325,8 +333,8 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ } THEN("result3 contains expected messages"){ - m::recorded_type items[] = { - m::on_completed(900) + record items[] = { + on_completed(900) }; auto required = rxu::to_vector(items); auto actual = results3.get_observer().messages(); @@ -341,68 +349,73 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ SCENARIO("subject - on_error in source", "[subject][subjects]"){ GIVEN("a subject and a source with an error"){ - auto sc = std::make_shared(); + auto sc = rxsc::make_test(); typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; std::runtime_error ex("subject on_error in stream"); - m::recorded_type messages[] = { - m::on_next(70, 1), - m::on_next(110, 2), - m::on_next(220, 3), - m::on_next(270, 4), - m::on_next(340, 5), - m::on_next(410, 6), - m::on_next(520, 7), - m::on_error(630, ex), - m::on_next(640, 9), - m::on_completed(650), - m::on_error(660, std::runtime_error("error on unsubscribed stream")) + record messages[] = { + on_next(70, 1), + on_next(110, 2), + on_next(220, 3), + on_next(270, 4), + on_next(340, 5), + on_next(410, 6), + on_next(520, 7), + on_error(630, ex), + on_next(640, 9), + on_completed(650), + on_error(660, std::runtime_error("error on unsubscribed stream")) }; - auto xs = sc->make_hot_observable(messages); + auto xs = sc.make_hot_observable(messages); rxsub::subject s; - auto results1 = sc->make_subscriber(); + auto results1 = sc.make_subscriber(); - auto results2 = sc->make_subscriber(); + auto results2 = sc.make_subscriber(); - auto results3 = sc->make_subscriber(); + auto results3 = sc.make_subscriber(); WHEN("multicasting an infinite source"){ auto o = s.get_subscriber(); - sc->schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ s = rxsub::subject(); o = s.get_subscriber();}); - sc->schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ xs.subscribe(o);}); - sc->schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + sc.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ o.unsubscribe();}); - sc->schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results1);}); - sc->schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + sc.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results2);}); - sc->schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + sc.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results3);}); - sc->schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc->schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + sc.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ results2.unsubscribe();}); - sc->schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + sc.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc->schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + sc.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ results3.unsubscribe();}); - sc->start(); + sc.start(); THEN("result1 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(340, 5), - m::on_next(410, 6), - m::on_next(520, 7) + record items[] = { + on_next(340, 5), + on_next(410, 6), + on_next(520, 7) }; auto required = rxu::to_vector(items); auto actual = results1.get_observer().messages(); @@ -410,10 +423,10 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ } THEN("result2 contains expected messages"){ - m::recorded_type items[] = { - m::on_next(410, 6), - m::on_next(520, 7), - m::on_error(630, ex) + record items[] = { + on_next(410, 6), + on_next(520, 7), + on_error(630, ex) }; auto required = rxu::to_vector(items); auto actual = results2.get_observer().messages(); @@ -421,8 +434,8 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ } THEN("result3 contains expected messages"){ - m::recorded_type items[] = { - m::on_error(900, ex) + record items[] = { + on_error(900, ex) }; auto required = rxu::to_vector(items); auto actual = results3.get_observer().messages(); diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 1d1f002..2ea1999 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -46,17 +46,15 @@ SCENARIO("subscriber traits", "[observer][traits]"){ REQUIRE(result == 1); } } - WHEN("onnext is called with 1 after error"){ + WHEN("after error"){ THEN("subscriber result is 10"){ scrbResult.on_error(std::current_exception()); - scrbResult.on_next(1); REQUIRE(result == 10); } } - WHEN("onnext is called with 1 after completed"){ + WHEN("after completed"){ THEN("subscriber result is 100"){ scrbResult.on_completed(); - scrbResult.on_next(1); REQUIRE(result == 100); } } @@ -150,47 +148,39 @@ SCENARIO("subscriber behavior", "[observer][traits]"){ REQUIRE(so.is_subscribed()); } } - WHEN("onnext is called with 1 after error"){ + WHEN("after error"){ THEN("dynamic_observer result is 10"){ dob.on_error(std::current_exception()); - dob.on_next(1); REQUIRE(result == 10); } THEN("static_observer result is 10"){ so.on_error(std::current_exception()); - so.on_next(1); REQUIRE(result == 10); } THEN("dynamic_observer is not subscribed"){ dob.on_error(std::current_exception()); - dob.on_next(1); REQUIRE(!dob.is_subscribed()); } THEN("static_observer is not subscribed"){ so.on_error(std::current_exception()); - so.on_next(1); REQUIRE(!so.is_subscribed()); } } - WHEN("onnext is called with 1 after completed"){ + WHEN("after completed"){ THEN("dynamic_observer result is 100"){ dob.on_completed(); - dob.on_next(1); REQUIRE(result == 100); } THEN("static_observer result is 100"){ so.on_completed(); - so.on_next(1); REQUIRE(result == 100); } THEN("dynamic_observer is not subscribed"){ dob.on_completed(); - dob.on_next(1); REQUIRE(!dob.is_subscribed()); } THEN("static_observer is not subscribed"){ so.on_completed(); - so.on_next(1); REQUIRE(!so.is_subscribed()); } } -- GitLab From 0519373432d51ae2ecdfa6a12e16df9c9c08103d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 23 Mar 2014 22:41:28 -0700 Subject: [PATCH 234/782] fix test scheduler - tests pass again --- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 68 ++++++++++--------- Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 16 ++--- 2 files changed, 45 insertions(+), 39 deletions(-) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 22e3897..443f7e8 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -23,12 +23,12 @@ public: using base::schedule_absolute; using base::schedule_relative; - virtual void schedule_absolute(long when, action a) const + virtual void schedule_absolute(long when, const schedulable& a) const { if (when <= base::clock_now) when = base::clock_now + 1; - return base::schedule_absolute(when, std::move(a)); + return base::schedule_absolute(when, a); } virtual long add(long absolute, long relative) const @@ -135,7 +135,7 @@ public: template cold_observable(typename test_type::shared sc, Iterator begin, Iterator end) - : scheduler(sc) + : sc(sc) , mv(begin, end) { } @@ -146,11 +146,13 @@ public: for (auto& message : mv) { auto n = message.value(); - sc->schedule_relative(message.time(), make_action([n, o](const schedulable& scbl) { - n->accept(o); - scbl.unsubscribe(); - return scbl; - })); + sc->schedule_relative(message.time(), make_schedulable( + scheduler(std::static_pointer_cast(sc)), + [n, o](const schedulable& scbl) { + if (o.is_subscribed()) { + n->accept(o); + } + })); } auto sharedThis = std::static_pointer_cast(this->shared_from_this()); @@ -195,13 +197,16 @@ public: { for (auto& message : mv) { auto n = message.value(); - sc->schedule_absolute(message.time(), make_action([this, n](const schedulable& scbl) { - auto local = this->observers; - for (auto& o : local) { - n->accept(o); - } - return schedulable::empty(scbl.get_scheduler()); - })); + sc->schedule_absolute(message.time(), make_schedulable( + scheduler(std::static_pointer_cast(sc)), + [this, n](const schedulable& scbl) { + auto local = this->observers; + for (auto& o : local) { + if (o.is_subscribed()) { + n->accept(o); + } + } + })); } } @@ -234,13 +239,14 @@ rxt::testable_observable test_type::make_hot_observable(std::vector(t)) + , tester(t) { } @@ -292,25 +298,25 @@ public: ~messages(); }; - void schedule_absolute(long when, action a) const { - tester->schedule_absolute(when, std::move(a)); + void schedule_absolute(long when, const schedulable& a) const { + tester->schedule_absolute(when, a); } - void schedule_relative(long when, action a) const { - tester->schedule_relative(when, std::move(a)); + void schedule_relative(long when, const schedulable& a) const { + tester->schedule_relative(when, a); } template - typename std::enable_if::type, action>::value, void>::type + typename std::enable_if::type, schedulable>::value, void>::type schedule_absolute(long when, F f) const { - tester->schedule_absolute(when, make_action(f)); + tester->schedule_absolute(when, make_schedulable(*this, f)); } template - typename std::enable_if::type, action>::value, void>::type + typename std::enable_if::type, schedulable>::value, void>::type schedule_relative(long when, F f) const { - tester->schedule_relative(when, make_action(f)); + tester->schedule_relative(when, make_schedulable(*this, f)); } template @@ -335,15 +341,15 @@ public: }; std::shared_ptr state(new state_type(this->make_subscriber())); - schedule_absolute(created, make_action([createSrc, state](const schedulable& scbl) { + schedule_absolute(created, [createSrc, state](const schedulable& scbl) { state->source.reset(new typename state_type::source_type(createSrc())); - })); - schedule_absolute(subscribed, make_action([state](const schedulable& scbl) { + }); + schedule_absolute(subscribed, [state](const schedulable& scbl) { state->source->subscribe(state->o); - })); - schedule_absolute(unsubscribed, make_action([state](const schedulable& scbl) { + }); + schedule_absolute(unsubscribed, [state](const schedulable& scbl) { state->o.unsubscribe(); - })); + }); tester->start(); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index 974e6d6..5d6c759 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -56,11 +56,11 @@ protected: virtual bool empty() const =0; public: - virtual void schedule_absolute(absolute, action) const =0; + virtual void schedule_absolute(absolute, const schedulable&) const =0; - virtual void schedule_relative(relative when, action a) const { + virtual void schedule_relative(relative when, const schedulable& a) const { auto at = add(clock_now, when); - return schedule_absolute(at, std::move(a)); + return schedule_absolute(at, a); } bool is_enabled() const {return isenabled;} @@ -162,15 +162,15 @@ public: } virtual void schedule(const schedulable& scbl) const { - schedule_absolute(clock_now, scbl.get_action()); + schedule_absolute(clock_now, scbl); } virtual void schedule(clock_type::duration when, const schedulable& scbl) const { - schedule_absolute(to_relative(when), scbl.get_action()); + schedule_absolute(to_relative(when), scbl); } virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { - schedule_absolute(to_relative(when - now()), scbl.get_action()); + schedule_absolute(to_relative(when - now()), scbl); } }; @@ -230,7 +230,7 @@ protected: using base::schedule_absolute; using base::schedule_relative; - virtual void schedule_absolute(typename base::absolute when, action a) const + virtual void schedule_absolute(typename base::absolute when, const schedulable& a) const { // use a separate subscription here so that a's subscription is not affected auto run = make_schedulable( @@ -240,7 +240,7 @@ protected: r.reset(false); if (scbl.is_subscribed()) { scbl.unsubscribe(); // unsubscribe() run, not a; - a(scbl, r.get_recurse()); + a(a, r.get_recurse()); } }); queue.push(item_type(when, run)); -- GitLab From 4e02f4b3cbda35b4b92ea07338a28b5703db078b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 24 Mar 2014 08:10:22 -0700 Subject: [PATCH 235/782] reduce race in subject --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 2 +- Rx/v2/test/subjects/subject.cpp | 97 +++++++++++++++++++------ 2 files changed, 76 insertions(+), 23 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index ff853ec..b74b356 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -59,8 +59,8 @@ class multicast_observer completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) : state(s) { - state->has_observers.exchange(true); ++state->completers; + state->has_observers.exchange(true); if (old) { observers.reserve(old->observers.size() + 1); std::copy_if( diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 06c2f49..ac8ed91 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -25,51 +25,72 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ const int onnextcalls = 10000000; { + std::mutex m; int c = 0; int n = 1; - auto o = rx::make_observer([&c](int){++c;}); auto start = clock::now(); for (int i = 0; i < onnextcalls; i++) { - o.on_next(i); + std::unique_lock guard(m); + ++c; } - o.on_completed(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "loop no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } { int c = 0; int n = 1; + auto o = rx::make_observer( + [&c](int){++c;}, + [](std::exception_ptr){abort();}); auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe( - [&c](int){ - ++c; - }); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); + } + o.on_completed(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "range no subject : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop -> observer : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } { - std::mutex m; int c = 0; int n = 1; + auto o = rx::make_observer( + [&c](int){++c;}, + [](std::exception_ptr){abort();}); auto start = clock::now(); for (int i = 0; i < onnextcalls; i++) { - std::unique_lock guard(m); - ++c; + o.on_next(i); } + o.on_completed(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + + { + int c = 0; + int n = 1; + auto start = clock::now(); + rxs::range(0, onnextcalls).subscribe( + [&c](int){ + ++c; + }, + [](std::exception_ptr){abort();}); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "range -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } for (int n = 0; n < 10; n++) { + auto p = std::make_shared(0); auto c = std::make_shared(0); rxsub::subject sub; @@ -79,6 +100,11 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ auto o = sub.get_subscriber(); + o.add(rx::make_subscription([c, n, onnextcalls](){ + auto expected = n * onnextcalls; + REQUIRE(*c == expected); + })); + for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC f[i] = std::async([sub, o]() { @@ -88,27 +114,37 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ rx::composite_subscription cs; source.subscribe(cs, [cs](int){ cs.unsubscribe(); - }); + }, + [](std::exception_ptr){abort();}); } return 0; }); #endif - sub.get_observable().subscribe([c](int){++(*c);}); + sub.get_observable().subscribe( + [c, p](int){ + ++(*c); + }, + [](std::exception_ptr){abort();}); } auto start = clock::now(); for (int i = 0; i < onnextcalls; i++) { +#if RXCPP_DEBUG_SUBJECT_RACE + if (*p != *c) abort(); + (*p) += n; +#endif o.on_next(i); } o.on_completed(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "loop : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "loop -> subject : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } for (int n = 0; n < 10; n++) { + auto p = std::make_shared(0); auto c = std::make_shared(0); rxsub::subject sub; @@ -118,6 +154,11 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ auto o = sub.get_subscriber(); + o.add(rx::make_subscription([c, n, onnextcalls](){ + auto expected = n * onnextcalls; + REQUIRE(*c == expected); + })); + for (int i = 0; i < n; i++) { #if RXCPP_SUBJECT_TEST_ASYNC f[i] = std::async([sub, o]() { @@ -126,23 +167,35 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ rx::composite_subscription cs; sub.get_observable().subscribe(cs, [cs](int){ cs.unsubscribe(); - }); + }, + [](std::exception_ptr){abort();}); } return 0; }); #endif sub.get_observable() - // demonstrates insertion of user definied operator - .op(rxo::filter([](int){return true;})) - .subscribe([c](int){++(*c);}); + .subscribe( + [c, p](int){ + ++(*c); + }, + [](std::exception_ptr){abort();} + ); } auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe(o); + rxs::range(0, onnextcalls) +#if RXCPP_DEBUG_SUBJECT_RACE + .filter([c, p, n](int){ + if (*p != *c) abort(); + (*p) += n; + return true; + }) +#endif + .subscribe(o); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "range : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "range -> subject : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } } } -- GitLab From 087ba2b7de05e9922809799754fce7a40bd09698 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 24 Mar 2014 11:50:39 -0700 Subject: [PATCH 236/782] fix race *and* improve perf in subject that is rare! --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 42 ++++++++++++------------- Rx/v2/test/subjects/subject.cpp | 4 +-- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index b74b356..b252674 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -40,8 +40,7 @@ class multicast_observer : current(mode::Casting) { } - std::atomic has_observers; - std::atomic completers; + std::atomic generation; std::mutex lock; typename mode::type current; std::exception_ptr error; @@ -52,15 +51,10 @@ class multicast_observer { ~completer_type() { - if (--state->completers == 0) { - state->has_observers.exchange(false); - } } completer_type(std::shared_ptr s, const std::shared_ptr& old, observer_type o) : state(s) { - ++state->completers; - state->has_observers.exchange(true); if (old) { observers.reserve(old->observers.size() + 1); std::copy_if( @@ -76,7 +70,7 @@ class multicast_observer list_type observers; }; - // this type exists to prevent a circular ref between state and completer + // this type prevents a circular ref between state and completer struct binder_type : public std::enable_shared_from_this { @@ -87,6 +81,10 @@ class multicast_observer std::shared_ptr state; + // used to avoid taking lock in on_next + mutable int current_generation; + mutable std::shared_ptr current_completer; + // must only be accessed under state->lock mutable std::shared_ptr completer; }; @@ -106,7 +104,7 @@ public: { } bool has_observers() const { - return b->state->has_observers; + return b->current_completer && !b->current_completer->observers.empty(); } void add(observer_type o) const { std::unique_lock guard(b->state->lock); @@ -115,6 +113,7 @@ public: { if (o.is_subscribed()) { b->completer = std::make_shared(b->state, b->completer, o); + ++b->state->generation; } } break; @@ -138,19 +137,20 @@ public: } } void on_next(T t) const { - if (has_observers()) { - std::shared_ptr c; - { - std::unique_lock guard(b->state->lock); - if (!b->completer) { - return; - } - c = b->completer; + if (b->current_generation != b->state->generation) { + std::unique_lock guard(b->state->lock); + if (!b->completer) { + return; } - for (auto& o : c->observers) { - if (o.is_subscribed()) { - o.on_next(t); - } + b->current_generation = b->state->generation; + b->current_completer = b->completer; + } + if (!b->current_completer || b->current_completer->observers.empty()) { + return; + } + for (auto& o : b->current_completer->observers) { + if (o.is_subscribed()) { + o.on_next(t); } } } diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index ac8ed91..0cec63f 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -1,5 +1,5 @@ -#define RXCPP_SUBJECT_TEST_ASYNC 1 +#define RXCPP_SUBJECT_TEST_ASYNC 0 #include "rxcpp/rx.hpp" namespace rx=rxcpp; @@ -22,7 +22,7 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ using namespace std::chrono; typedef steady_clock clock; - const int onnextcalls = 10000000; + const int onnextcalls = 100000000; { std::mutex m; -- GitLab From 1f064fed0f023426bfbe8e00dd751999665d40f1 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 24 Mar 2014 12:21:11 -0700 Subject: [PATCH 237/782] initialize current_generation --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 1 + Rx/v2/test/subjects/subject.cpp | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index b252674..a0b606f 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -76,6 +76,7 @@ class multicast_observer { binder_type() : state(std::make_shared()) + , current_generation(0) { } diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 0cec63f..9a7544a 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -1,5 +1,5 @@ -#define RXCPP_SUBJECT_TEST_ASYNC 0 +#define RXCPP_SUBJECT_TEST_ASYNC 1 #include "rxcpp/rx.hpp" namespace rx=rxcpp; -- GitLab From c64d4b8319d7198fdb16721b5ae3c3577dd3935e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 25 Mar 2014 12:49:46 -0700 Subject: [PATCH 238/782] changes to arg resolver --- Rx/v2/src/rxcpp/rx-observer.hpp | 28 ++--- Rx/v2/src/rxcpp/rx-util.hpp | 188 +++++++++++++++++++++++--------- 2 files changed, 148 insertions(+), 68 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 0aee374..c1e22a9 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -244,18 +244,7 @@ auto make_observer() } namespace detail { - -template -auto make_observer_resolved(ResolvedArgSet&& rs) - -> observer(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>> { - return make_observer_resolved(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>>(std::forward(rs)); -} -template -auto make_observer_dynamic_resolved(ResolvedArgSet&& rs) - -> observer> { - return make_observer_resolved>(std::forward(rs)); -} - + template auto make_observer_resolved(ResolvedArgSet&& rs) -> observer { @@ -264,17 +253,28 @@ auto make_observer_resolved(ResolvedArgSet&& rs) std::move(std::get<0>(std::forward(rs)).value), std::move(std::get<1>(std::forward(rs)).value), std::move(std::get<2>(std::forward(rs)).value))); - + typedef typename std::decay(std::forward(rs)))>::type rn_t; typedef typename std::decay(std::forward(rs)))>::type re_t; typedef typename std::decay(std::forward(rs)))>::type rc_t; - + static_assert(rn_t::is_arg, "onnext is a required parameter"); static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); static_assert(!(re_t::is_arg && rc_t::is_arg) || re_t::n + 1 == rc_t::n, "onerror, oncompleted parameters must be together and in order"); static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); } +template +auto make_observer_resolved(ResolvedArgSet&& rs) + -> observer(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>> { + return make_observer_resolved(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>>(std::forward(rs)); +} +template +auto make_observer_dynamic_resolved(ResolvedArgSet&& rs) + -> observer> { + return make_observer_resolved>(std::forward(rs)); +} + template struct tag_onnext_resolution { diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 71d75c7..61d4786 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -200,8 +200,6 @@ private: #if RXCPP_USE_VARIADIC_TEMPLATES -namespace detail { - template struct select_arg { @@ -221,44 +219,59 @@ struct select_arg } }; -} +template +struct resolved_arg +{ + typedef resolved_arg this_type; + static const int n = N; + static const bool is_arg = true; + typedef T result_type; + result_type value; + template + explicit resolved_arg(Value&& v) + : value(std::forward(v)) + { + } + template + static this_type make(CArgN&&... can) { + return this_type(select_arg::get(std::forward(can)...)); + } +}; + +template +struct resolved_arg<-1, T> +{ + typedef resolved_arg<-1, T> this_type; + static const int n = -1; + static const bool is_arg = false; + typedef T result_type; + result_type value; + template + static this_type make(CArgN&&... can) { + return this_type(); + } +}; template class Predicate, class Default, class... ArgN> struct arg_resolver_n; - + template class Predicate, class Default, class Arg, class... ArgN> struct arg_resolver_n { static const int n = N; - static const bool is_arg = true; - typedef Arg result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n next_type; - typedef typename std::conditional::value, this_type, typename next_type::type>::type type; - result_type value; - template - arg_resolver_n(CArgN&&... can) - : value(detail::select_arg::get(std::forward(can)...)) { - } + typedef typename std::conditional::value, this_type, typename next_type::type>::type type; }; template class Predicate, class Default> struct arg_resolver_n { static const int n = -1; - static const bool is_arg = false; - typedef Default result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef this_type type; - result_type value; - template - struct select_arg - { - }; - template - arg_resolver_n(CArgN&&...) - : value() { - } }; #else template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> @@ -274,9 +287,14 @@ struct arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; + arg_resolver_n(result_type v) + : value(std::move(v)) + { + } template - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, R&& a) - : value(std::forward(a)) { + static this_type make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, R&& a) + { + return this_type(std::forward(a)); } }; @@ -290,9 +308,14 @@ struct arg_resolver_n<4, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; + arg_resolver_n(result_type v) + : value(std::move(v)) + { + } template - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, R&& a, const Arg5&) - : value(std::forward(a)) { + static this_type make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, R&& a, const Arg5&) + { + return this_type(std::forward(a)); } }; @@ -306,9 +329,14 @@ struct arg_resolver_n<3, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; + arg_resolver_n(result_type v) + : value(std::move(v)) + { + } template - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, R&& a, const Arg4&, const Arg5&) - : value(std::forward(a)) { + static this_type make(const Arg0&, const Arg1&, const Arg2&, R&& a, const Arg4&, const Arg5&) + { + return this_type(std::forward(a)); } }; @@ -322,9 +350,14 @@ struct arg_resolver_n<2, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; + arg_resolver_n(result_type v) + : value(std::move(v)) + { + } template - arg_resolver_n(const Arg0&, const Arg1&, R&& a, const Arg3&, const Arg4&, const Arg5&) - : value(std::forward(a)) { + static this_type make(const Arg0&, const Arg1&, R&& a, const Arg3&, const Arg4&, const Arg5&) + { + return this_type(std::forward(a)); } }; @@ -338,9 +371,14 @@ struct arg_resolver_n<1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; + arg_resolver_n(result_type v) + : value(std::move(v)) + { + } template - arg_resolver_n(const Arg0&, R&& a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - : value(std::forward(a)) { + static this_type make(const Arg0&, R&& a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + { + return this_type(std::forward(a)); } }; @@ -354,9 +392,14 @@ struct arg_resolver_n<0, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; result_type value; + arg_resolver_n(result_type v) + : value(std::move(v)) + { + } template - arg_resolver_n(R&& a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - : value(std::forward(a)) { + static this_type make(R&& a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + { + return this_type(std::forward(a)); } }; @@ -369,18 +412,55 @@ struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5 typedef arg_resolver_n this_type; typedef this_type type; result_type value; - arg_resolver_n(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - : value() { + static this_type make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + { + return this_type(); } }; #endif #if RXCPP_USE_VARIADIC_TEMPLATES +template +struct select_first; + +template +struct select_first +{ + static const int value = Predicate0 ? N : select_first::value; +}; +template +struct select_first +{ + static const int value = -1; +}; + +template +struct select_n +{ + struct type; +}; + +template +struct select_n : public select_n +{ +}; + +template +struct select_n +{ + typedef SArg0 type; +}; + template class Predicate, class Default, class... ArgN> struct arg_resolver { - typedef typename arg_resolver_n::type...>::type type; + typedef select_first<0, Predicate::value...> match; + typedef typename std::conditional< + match::value != -1, + typename select_n::type, + Default>::type result_type; + typedef resolved_arg resolved_type; }; #else struct tag_unresolvable {}; @@ -395,65 +475,65 @@ struct arg_resolver template class Predicate, class Default, class... ArgN> auto resolve_arg(ArgN&&... an) --> decltype(typename arg_resolver::type(std::forward(an)...)) { - return typename arg_resolver::type(std::forward(an)...); +-> decltype(arg_resolver::resolved_type::make(std::forward(an)...)) { + return arg_resolver::resolved_type::make(std::forward(an)...); } #else template class Predicate, class Default> auto resolve_arg() --> decltype(typename arg_resolver::type(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); +-> decltype(typename arg_resolver::type::make(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + return typename arg_resolver::type::make(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0> auto resolve_arg(Arg0&& a0) --> decltype(typename arg_resolver::type(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); +-> decltype(typename arg_resolver::type::make(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { + return typename arg_resolver::type::make(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1> auto resolve_arg(Arg0&& a0, Arg1&& a1) --> decltype(typename arg_resolver::type( +-> decltype(typename arg_resolver::type::make( std::forward(a0), std::forward(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type( + return typename arg_resolver::type::make( std::forward(a0), std::forward(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2> auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2) --> decltype(typename arg_resolver::type( +-> decltype(typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type( + return typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3> auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) --> decltype(typename arg_resolver::type( +-> decltype(typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type( + return typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), tag_unresolvable(), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4> auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) --> decltype(typename arg_resolver::type( +-> decltype(typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), tag_unresolvable())) { - return typename arg_resolver::type( + return typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), tag_unresolvable()); } template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) --> decltype(typename arg_resolver::type( +-> decltype(typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))) { - return typename arg_resolver::type( + return typename arg_resolver::type::make( std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)); } #endif -- GitLab From 74584fa6e19877fb41d3ef4964467bb890b1fa3a Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Tue, 25 Mar 2014 12:50:36 -0700 Subject: [PATCH 239/782] changes for windows compilation --- Rx/v2/src/rxcpp/rx-predef.hpp | 4 ++-- Rx/v2/src/rxcpp/rx-scheduler.hpp | 4 ++-- Rx/v2/src/rxcpp/rx-subscription.hpp | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 18c356d..1926c17 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -60,11 +60,11 @@ template class is_observer { template - static typename C::observer_tag check(int); + static typename C::observer_tag* check(int); template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_observer>::value; + static const bool value = std::is_convertible::type>(0)), tag_observer*>::value; }; struct tag_dynamic_observer {}; diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 6bd5a8b..cadc173 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -277,8 +277,8 @@ class schedulable : public schedulable_base recursed_scope_type recursed_scope; public: - typedef typename composite_subscription::weak_subscription weak_subscription; - typedef typename composite_subscription::shared_subscription shared_subscription; + typedef composite_subscription::weak_subscription weak_subscription; + typedef composite_subscription::shared_subscription shared_subscription; typedef scheduler_base::clock_type clock_type; schedulable() diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 192bff4..8d11f4d 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -16,11 +16,11 @@ template class is_subscription { template - static typename C::subscription_tag check(int); + static typename C::subscription_tag* check(int); template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_subscription>::value; + static const bool value = std::is_convertible::type>(0)), tag_subscription*>::value; }; class dynamic_subscription : public subscription_base -- GitLab From 3c54077a4f8f1eaa6203fdb8f942235b8cdfcb2c Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 26 Mar 2014 11:14:05 -0700 Subject: [PATCH 240/782] more windows compilation work still running into hard limit on linkage spec's in msvc --- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 2 + Rx/v2/src/rxcpp/rx-includes.hpp | 63 +++-- Rx/v2/src/rxcpp/rx-observer.hpp | 30 +- Rx/v2/src/rxcpp/rx-util.hpp | 317 ++++++++-------------- 4 files changed, 170 insertions(+), 242 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index a52d3c8..554ea15 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -31,7 +31,9 @@ struct flat_map_traits { typedef decltype((*(collection_selector_type*)nullptr)((*(source_value_type*)nullptr))) collection_type; +#if _MSC_VER >= 1900 static_assert(is_observable::value, "flat_map CollectionSelector must return an observable"); +#endif typedef typename collection_type::value_type collection_value_type; diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 9131716..ba13539 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -5,35 +5,6 @@ #if !defined(RXCPP_RX_INCLUDES_HPP) #define RXCPP_RX_INCLUDES_HPP -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max - -#include - -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - // some configuration macros #if defined(_MSC_VER) @@ -90,6 +61,40 @@ #define RXCPP_USE_WINRT RXCPP_FORCE_USE_WINRT #endif +#if defined(_MSC_VER) && !RXCPP_USE_VARIADIC_TEMPLATES +// resolve args needs enough to store all the possible resolved args +#define _VARIADIC_MAX 10 +#endif + +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max + +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include "rx-util.hpp" #include "rx-predef.hpp" #include "rx-subscription.hpp" diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index c1e22a9..26d998f 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -244,35 +244,51 @@ auto make_observer() } namespace detail { - + template -auto make_observer_resolved(ResolvedArgSet&& rs) +auto make_observer_resolved_explicit(ResolvedArgSet&& rs) -> observer { typedef I inner_type; return observer(inner_type( std::move(std::get<0>(std::forward(rs)).value), std::move(std::get<1>(std::forward(rs)).value), std::move(std::get<2>(std::forward(rs)).value))); - + typedef typename std::decay(std::forward(rs)))>::type rn_t; typedef typename std::decay(std::forward(rs)))>::type re_t; typedef typename std::decay(std::forward(rs)))>::type rc_t; - + static_assert(rn_t::is_arg, "onnext is a required parameter"); static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); static_assert(!(re_t::is_arg && rc_t::is_arg) || re_t::n + 1 == rc_t::n, "onerror, oncompleted parameters must be together and in order"); static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); } +template +struct resolved_observer_traits +{ + typedef typename std::decay::type resolved_set; + typedef typename std::tuple_element<0, resolved_set>::type resolved_on_next; + typedef typename std::tuple_element<1, resolved_set>::type resolved_on_error; + typedef typename std::tuple_element<2, resolved_set>::type resolved_on_completed; + template + struct static_observer_of + { + typedef static_observer type; + }; +}; template auto make_observer_resolved(ResolvedArgSet&& rs) - -> observer(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>> { - return make_observer_resolved(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type, typename std::decay(std::forward(rs)))>::type::result_type>>(std::forward(rs)); + -> observer::template static_observer_of::type> { + return make_observer_resolved_explicit::template static_observer_of::type>(std::forward(rs)); } template auto make_observer_dynamic_resolved(ResolvedArgSet&& rs) -> observer> { - return make_observer_resolved>(std::forward(rs)); + return make_observer_resolved_explicit>(std::forward(rs)); } template diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 61d4786..9132aaf 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -227,14 +227,15 @@ struct resolved_arg static const bool is_arg = true; typedef T result_type; result_type value; + struct tag_value {}; template - explicit resolved_arg(Value&& v) - : value(std::forward(v)) + resolved_arg(Value&& v, tag_value&&) + : value(std::forward(v)) { } template static this_type make(CArgN&&... can) { - return this_type(select_arg::get(std::forward(can)...)); + return this_type(select_arg::get(std::forward(can)...), tag_value()); } }; @@ -252,28 +253,41 @@ struct resolved_arg<-1, T> } }; -template class Predicate, class Default, class... ArgN> -struct arg_resolver_n; +#else -template class Predicate, class Default, class Arg, class... ArgN> -struct arg_resolver_n +template +struct resolved_arg { + typedef resolved_arg this_type; static const int n = N; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n next_type; - typedef typename std::conditional::value, this_type, typename next_type::type>::type type; + static const bool is_arg = true; + typedef T result_type; + result_type value; + struct tag_value {}; + template + resolved_arg(Value&& v, tag_value&&) + : value(std::forward(v)) + { + } + template + static this_type make(Arg0&& a0) { + return this_type(std::forward(a0), tag_value()); + } }; -template class Predicate, class Default> -struct arg_resolver_n +template +struct resolved_arg<-1, T> { + typedef resolved_arg<-1, T> this_type; static const int n = -1; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef this_type type; + static const bool is_arg = false; + typedef T result_type; + result_type value; + static this_type make() { + return this_type(); + } }; -#else + template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct arg_resolver_n; @@ -283,18 +297,14 @@ struct arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> static const int n = 5; static const bool is_arg = true; typedef Arg5 result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - result_type value; - arg_resolver_n(result_type v) - : value(std::move(v)) - { - } template - static this_type make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, R&& a) + static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, R&& a) { - return this_type(std::forward(a)); + return resolved_arg::make(std::forward(a)); } }; @@ -304,18 +314,14 @@ struct arg_resolver_n<4, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> static const int n = 4; static const bool is_arg = true; typedef Arg4 result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - result_type value; - arg_resolver_n(result_type v) - : value(std::move(v)) - { - } template - static this_type make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, R&& a, const Arg5&) + static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, R&& a, const Arg5&) { - return this_type(std::forward(a)); + return resolved_arg::make(std::forward(a)); } }; @@ -325,18 +331,14 @@ struct arg_resolver_n<3, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> static const int n = 3; static const bool is_arg = true; typedef Arg3 result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - result_type value; - arg_resolver_n(result_type v) - : value(std::move(v)) - { - } template - static this_type make(const Arg0&, const Arg1&, const Arg2&, R&& a, const Arg4&, const Arg5&) + static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, R&& a, const Arg4&, const Arg5&) { - return this_type(std::forward(a)); + return resolved_arg::make(std::forward(a)); } }; @@ -346,18 +348,14 @@ struct arg_resolver_n<2, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> static const int n = 2; static const bool is_arg = true; typedef Arg2 result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - result_type value; - arg_resolver_n(result_type v) - : value(std::move(v)) - { - } template - static this_type make(const Arg0&, const Arg1&, R&& a, const Arg3&, const Arg4&, const Arg5&) + static resolved_arg make(const Arg0&, const Arg1&, R&& a, const Arg3&, const Arg4&, const Arg5&) { - return this_type(std::forward(a)); + return resolved_arg::make(std::forward(a)); } }; @@ -367,18 +365,14 @@ struct arg_resolver_n<1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> static const int n = 1; static const bool is_arg = true; typedef Arg1 result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - result_type value; - arg_resolver_n(result_type v) - : value(std::move(v)) - { - } template - static this_type make(const Arg0&, R&& a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + static resolved_arg make(const Arg0&, R&& a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) { - return this_type(std::forward(a)); + return resolved_arg::make(std::forward(a)); } }; @@ -388,18 +382,14 @@ struct arg_resolver_n<0, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> static const int n = 0; static const bool is_arg = true; typedef Arg0 result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef arg_resolver_n prev_type; typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - result_type value; - arg_resolver_n(result_type v) - : value(std::move(v)) - { - } template - static this_type make(R&& a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + static resolved_arg make(R&& a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) { - return this_type(std::forward(a)); + return resolved_arg::make(std::forward(a)); } }; @@ -409,12 +399,12 @@ struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5 static const int n = -1; static const bool is_arg = false; typedef Default result_type; + typedef resolved_arg resolved_type; typedef arg_resolver_n this_type; typedef this_type type; - result_type value; - static this_type make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) + static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) { - return this_type(); + return resolved_arg(); } }; #endif @@ -475,7 +465,8 @@ struct arg_resolver template class Predicate, class Default, class... ArgN> auto resolve_arg(ArgN&&... an) --> decltype(arg_resolver::resolved_type::make(std::forward(an)...)) { +-> typename arg_resolver::resolved_type +{ return arg_resolver::resolved_type::make(std::forward(an)...); } #else @@ -543,10 +534,11 @@ struct arg_resolver_term {}; // // use to build a set of tags // -template -struct tag_set : Base +template +struct tag_set { - typedef Next next_tag; + typedef Tag tag; + typedef NextSet next_set; }; template @@ -560,81 +552,82 @@ struct arg_resolver_set } }; -template +template struct arg_resolver_set { - typedef arg_resolver_set next_set; + typedef typename TagSet::tag tag; + typedef arg_resolver_set next_set; #if RXCPP_USE_VARIADIC_TEMPLATES template auto operator()(ArgN&&... an) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(an)...)), + std::make_tuple(resolve_arg(std::forward(an)...)), next_set()(std::forward(an)...))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(an)...)), + std::make_tuple(resolve_arg(std::forward(an)...)), next_set()(std::forward(an)...)); } #else inline auto operator()() -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg()), + std::make_tuple(resolve_arg()), next_set()())) { return std::tuple_cat( - std::make_tuple(resolve_arg()), + std::make_tuple(resolve_arg()), next_set()()); } template auto operator()(Arg0&& a0) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0))), + std::make_tuple(resolve_arg(std::forward(a0))), next_set()(std::forward(a0)))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0))), + std::make_tuple(resolve_arg(std::forward(a0))), next_set()(std::forward(a0))); } template auto operator()(Arg0&& a0, Arg1&& a1) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), next_set()(std::forward(a0), std::forward(a1)))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), next_set()(std::forward(a0), std::forward(a1))); } template auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2)))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2))); } template auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); } template auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); } template auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), + std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); } #endif @@ -645,143 +638,55 @@ template inline std::tuple<> resolve_arg_set(arg_resolver_term&&, ArgN&&... ) { return std::tuple<>(); } -#else -inline std::tuple<> resolve_arg_set(arg_resolver_term&&) { - return std::tuple<>(); -} - -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& ) { - return std::tuple<>(); -} - -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& ) { - return std::tuple<>(); -} - -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& ) { - return std::tuple<>(); -} - -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& ) { - return std::tuple<>(); -} - -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& , Arg4&& ) { - return std::tuple<>(); -} - -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, Arg0&& , Arg1&& , Arg2&& , Arg3&& , Arg4&& , Arg5&& ) { - return std::tuple<>(); -} -#endif -#if RXCPP_USE_VARIADIC_TEMPLATES -template -auto resolve_arg_set(Tag&&, ArgN&&... an) +template +auto resolve_arg_set(TagSet&&, ArgN&&... an) -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( + std::make_tuple(resolve_arg( std::forward(an)...)), - resolve_arg_set(typename Tag::next_tag(), + resolve_arg_set(typename TagSet::next_set(), std::forward(an)...))) { return std::tuple_cat( - std::make_tuple(resolve_arg( + std::make_tuple(resolve_arg( std::forward(an)...)), - resolve_arg_set(typename Tag::next_tag(), + resolve_arg_set(typename TagSet::next_set(), std::forward(an)...)); } #else -template -auto resolve_arg_set(Tag&&) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg()), - resolve_arg_set(typename Tag::next_tag()))) { - return std::tuple_cat( - std::make_tuple(resolve_arg()), - resolve_arg_set(typename Tag::next_tag())); +template +auto resolve_arg_set(TagSet&&) + -> decltype(arg_resolver_set()()) { + return arg_resolver_set()(); } -template -auto resolve_arg_set(Tag&&, Arg0&& a0) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0))); +template +auto resolve_arg_set(TagSet&&, Arg0&& a0) + -> decltype(arg_resolver_set()(std::forward(a0))) { + return arg_resolver_set()(std::forward(a0)); } -template -auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1))); +template +auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1) + -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1))) { + return arg_resolver_set()(std::forward(a0), std::forward(a1)); } -template -auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2))); +template +auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2) + -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2))) { + return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2)); } -template -auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); +template +auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) + -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))) { + return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)); } -template -auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); +template +auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) + -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))) { + return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)); } -template -auto resolve_arg_set(Tag&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), - resolve_arg_set(typename Tag::next_tag(), - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); +template +auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) + -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))) { + return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)); } #endif -- GitLab From 5fb44100464a3aaefe8bd4d8dc4a42afd5e2de19 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Wed, 26 Mar 2014 23:03:21 -0700 Subject: [PATCH 241/782] windows compiles! gave up on compilers that do not have variadic support - at least for now --- Rx/v2/src/rxcpp/rx-observable.hpp | 98 ------- Rx/v2/src/rxcpp/rx-observer.hpp | 64 +---- Rx/v2/src/rxcpp/rx-scheduler.hpp | 64 +---- Rx/v2/src/rxcpp/rx-subscriber.hpp | 55 +--- Rx/v2/src/rxcpp/rx-util.hpp | 417 +++--------------------------- Rx/v2/test/subjects/subject.cpp | 22 ++ 6 files changed, 91 insertions(+), 629 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index c062ae2..2b59544 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -223,7 +223,6 @@ public: return *this; } -#if RXCPP_USE_VARIADIC_TEMPLATES /// /// subscribe will cause this observable to emit values to the provided subscriber. /// callers must provide enough arguments to make a subscriber. @@ -239,103 +238,6 @@ public: -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...))) { return detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...)); } -#else - /// - /// subscribe will cause this observable to emit values to the provided subscriber. - /// callers must provide enough arguments to make a subscriber. - /// overrides are supported. thus - /// subscribe(thesubscriber, composite_subscription()) - /// will take thesubscriber.get_observer() and the provided - /// subscription and subscribe to the new subscriber. - /// the on_next, on_error, on_completed methods can be supplied instead of an observer - /// if a subscription or subscriber is not provided then a new subscription will be created. - /// - template - auto subscribe(Arg0&& a0) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0)))) { - return detail_subscribe(make_subscriber(std::forward(a0))); - } - - /// - /// subscribe will cause this observable to emit values to the provided subscriber. - /// callers must provide enough arguments to make a subscriber. - /// overrides are supported. thus - /// subscribe(thesubscriber, composite_subscription()) - /// will take thesubscriber.get_observer() and the provided - /// subscription and subscribe to the new subscriber. - /// the on_next, on_error, on_completed methods can be supplied instead of an observer - /// if a subscription or subscriber is not provided then a new subscription will be created. - /// - template - auto subscribe(Arg0&& a0, Arg1&& a1) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1)))) { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1))); - } - - /// - /// subscribe will cause this observable to emit values to the provided subscriber. - /// callers must provide enough arguments to make a subscriber. - /// overrides are supported. thus - /// subscribe(thesubscriber, composite_subscription()) - /// will take thesubscriber.get_observer() and the provided - /// subscription and subscribe to the new subscriber. - /// the on_next, on_error, on_completed methods can be supplied instead of an observer - /// if a subscription or subscriber is not provided then a new subscription will be created. - /// - template - auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2)))) { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2))); - } - - /// - /// subscribe will cause this observable to emit values to the provided subscriber. - /// callers must provide enough arguments to make a subscriber. - /// overrides are supported. thus - /// subscribe(thesubscriber, composite_subscription()) - /// will take thesubscriber.get_observer() and the provided - /// subscription and subscribe to the new subscriber. - /// the on_next, on_error, on_completed methods can be supplied instead of an observer - /// if a subscription or subscriber is not provided then a new subscription will be created. - /// - template - auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); - } - - /// - /// subscribe will cause this observable to emit values to the provided subscriber. - /// callers must provide enough arguments to make a subscriber. - /// overrides are supported. thus - /// subscribe(thesubscriber, composite_subscription()) - /// will take thesubscriber.get_observer() and the provided - /// subscription and subscribe to the new subscriber. - /// the on_next, on_error, on_completed methods can be supplied instead of an observer - /// if a subscription or subscriber is not provided then a new subscription will be created. - /// - template - auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); - } - - /// - /// subscribe will cause this observable to emit values to the provided subscriber. - /// callers must provide enough arguments to make a subscriber. - /// overrides are supported. thus - /// subscribe(thesubscriber, composite_subscription()) - /// will take thesubscriber.get_observer() and the provided - /// subscription and subscribe to the new subscriber. - /// the on_next, on_error, on_completed methods can be supplied instead of an observer - /// if a subscription or subscriber is not provided then a new subscription will be created. - /// - template - auto subscribe(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); - } -#endif /// filter (AKA Where) -> /// for each item from this observable use Predicate to select which items to emit from the new observable that is returned. diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 26d998f..ec40195 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -267,6 +267,9 @@ template struct resolved_observer_traits { typedef typename std::decay::type resolved_set; + + static_assert(std::tuple_size::value >= 3, "must have at least three resolved arguments"); + typedef typename std::tuple_element<0, resolved_set>::type resolved_on_next; typedef typename std::tuple_element<1, resolved_set>::type resolved_on_error; typedef typename std::tuple_element<2, resolved_set>::type resolved_on_completed; @@ -323,78 +326,29 @@ struct tag_oncompleted_resolution }; // types to disambiguate -// on_next and optional on_error, on_completed + -// optional subscription +// on_next and optional on_error, on_completed // template struct tag_observer_set - : public rxu::detail::tag_set, - rxu::detail::tag_set>> { + typedef rxu::detail::tag_set, tag_onerror_resolution, tag_oncompleted_resolution> type; }; } -#if RXCPP_USE_VARIADIC_TEMPLATES template auto make_observer(Arg0&& a0, ArgN&&... an) - -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...))) { - return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...)); -} -#else -template -auto make_observer(Arg0&& a0) - -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0)))) { - return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0))); -} -template -auto make_observer(Arg0&& a0, Arg1&& a1) - -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1)))) { - return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1))); -} -template -auto make_observer(Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { - return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2))); -} -template -auto make_observer(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return detail::make_observer_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); + -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...))) { + return detail::make_observer_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...)); } -#endif -#if RXCPP_USE_VARIADIC_TEMPLATES template auto make_observer_dynamic(Arg0&& a0, ArgN&&... an) - -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...))) { - return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(an)...)); -} -#else -template -auto make_observer_dynamic(Arg0&& a0) - -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0)))) { - return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0))); -} -template -auto make_observer_dynamic(Arg0&& a0, Arg1&& a1) - -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1)))) { - return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1))); + -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...))) { + return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...)); } -template -auto make_observer_dynamic(Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { - return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2))); -} -template -auto make_observer_dynamic(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(detail::tag_observer_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); -} -#endif } diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index cadc173..f92a981 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -552,17 +552,13 @@ struct tag_scheduler_resolution }; -struct tag_schedulable_set - // the first four must be the same as tag_observer_set or the indexing will fail - : public rxu::detail::tag_set>>>>>> -{ -}; +typedef rxu::detail::tag_set tag_schedulable_set; template struct action_selector; @@ -639,61 +635,15 @@ schedulable schedule_resolved(ResolvedArgSet&& rsArg) { } -#if RXCPP_USE_VARIADIC_TEMPLATES template schedulable make_schedulable(Arg0&& a0, ArgN&&... an) { return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); } -#else -template -schedulable make_schedulable(Arg0&& a0) { - return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0))); -} -template -schedulable make_schedulable(Arg0&& a0, Arg1&& a1) { - return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1))); -} -template -schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2) { - return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2))); -} -template -schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) { - return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); -} -template -schedulable make_schedulable(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) { - return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); -} -#endif -#if RXCPP_USE_VARIADIC_TEMPLATES template schedulable schedule(Arg0&& a0, ArgN&&... an) { return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); } -#else -template -schedulable schedule(Arg0&& a0) { - return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0))); -} -template -schedulable schedule(Arg0&& a0, Arg1&& a1) { - return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1))); -} -template -schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2) { - return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2))); -} -template -schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) { - return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); -} -template -schedulable schedule(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) { - return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); -} -#endif namespace detail { diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 91086d8..d6a4deb 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -192,6 +192,7 @@ auto make_subscriber_resolved(ResolvedArgSet&& rsArg) return subscriber(*(typename std::decay::type*)nullptr))>( s, r, select_observer(rs)); + static_assert(std::tuple_size::value == 7, "must have 7 resolved args"); // at least for now do not enforce resolver #if 0 typedef typename std::decay::type rr_t; @@ -243,57 +244,25 @@ struct tag_resumption_resolution template struct tag_subscriber_set - // the first four must be the same as tag_observer_set or the indexing will fail - : public rxu::detail::tag_set, - rxu::detail::tag_set, - rxu::detail::tag_set>>>>>>> { + // the first four must be the same as tag_observer_set or the indexing will fail + typedef rxu::detail::tag_set< + tag_onnext_resolution, + tag_onerror_resolution, + tag_oncompleted_resolution, + tag_subscription_resolution, + tag_resumption_resolution, + tag_observer_resolution, + tag_subscriber_resolution> type; }; } -#if RXCPP_USE_VARIADIC_TEMPLATES template auto make_subscriber(Arg0&& a0, ArgN&&... an) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(an)...))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(an)...)); + -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(typename detail::tag_subscriber_set::type(), std::forward(a0), std::forward(an)...))) { + return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(typename detail::tag_subscriber_set::type(), std::forward(a0), std::forward(an)...)); } -#else -template -auto make_subscriber(Arg0&& a0) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0)))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0))); -} -template -auto make_subscriber(Arg0&& a0, Arg1&& a1) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1)))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1))); -} -template -auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2)))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2))); -} -template -auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); -} -template -auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); -} -template -auto make_subscriber(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(detail::tag_subscriber_set(), std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); -} -#endif } diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 9132aaf..6c7efa2 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -198,8 +198,6 @@ private: Function* function; }; -#if RXCPP_USE_VARIADIC_TEMPLATES - template struct select_arg { @@ -253,164 +251,7 @@ struct resolved_arg<-1, T> } }; -#else - -template -struct resolved_arg -{ - typedef resolved_arg this_type; - static const int n = N; - static const bool is_arg = true; - typedef T result_type; - result_type value; - struct tag_value {}; - template - resolved_arg(Value&& v, tag_value&&) - : value(std::forward(v)) - { - } - template - static this_type make(Arg0&& a0) { - return this_type(std::forward(a0), tag_value()); - } -}; - -template -struct resolved_arg<-1, T> -{ - typedef resolved_arg<-1, T> this_type; - static const int n = -1; - static const bool is_arg = false; - typedef T result_type; - result_type value; - static this_type make() { - return this_type(); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n; -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<5, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = 5; - static const bool is_arg = true; - typedef Arg5 result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n prev_type; - typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - template - static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, R&& a) - { - return resolved_arg::make(std::forward(a)); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<4, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = 4; - static const bool is_arg = true; - typedef Arg4 result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n prev_type; - typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - template - static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, R&& a, const Arg5&) - { - return resolved_arg::make(std::forward(a)); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<3, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = 3; - static const bool is_arg = true; - typedef Arg3 result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n prev_type; - typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - template - static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, R&& a, const Arg4&, const Arg5&) - { - return resolved_arg::make(std::forward(a)); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<2, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = 2; - static const bool is_arg = true; - typedef Arg2 result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n prev_type; - typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - template - static resolved_arg make(const Arg0&, const Arg1&, R&& a, const Arg3&, const Arg4&, const Arg5&) - { - return resolved_arg::make(std::forward(a)); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = 1; - static const bool is_arg = true; - typedef Arg1 result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n prev_type; - typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - template - static resolved_arg make(const Arg0&, R&& a, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - { - return resolved_arg::make(std::forward(a)); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<0, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = 0; - static const bool is_arg = true; - typedef Arg0 result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef arg_resolver_n prev_type; - typedef typename std::conditional::value, this_type, typename prev_type::type>::type type; - template - static resolved_arg make(R&& a, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - { - return resolved_arg::make(std::forward(a)); - } -}; - -template class Predicate, class Default, class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -struct arg_resolver_n<-1, Predicate, Default, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5> -{ - static const int n = -1; - static const bool is_arg = false; - typedef Default result_type; - typedef resolved_arg resolved_type; - typedef arg_resolver_n this_type; - typedef this_type type; - static resolved_arg make(const Arg0&, const Arg1&, const Arg2&, const Arg3&, const Arg4&, const Arg5&) - { - return resolved_arg(); - } -}; -#endif - - -#if RXCPP_USE_VARIADIC_TEMPLATES template struct select_first; @@ -452,243 +293,67 @@ struct arg_resolver Default>::type result_type; typedef resolved_arg resolved_type; }; -#else -struct tag_unresolvable {}; -template class Predicate, class Default, class Arg0 = tag_unresolvable, class Arg1 = tag_unresolvable, class Arg2 = tag_unresolvable, class Arg3 = tag_unresolvable, class Arg4 = tag_unresolvable, class Arg5 = tag_unresolvable> -struct arg_resolver -{ - typedef typename arg_resolver_n<5, Predicate, Default, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type, typename std::decay::type>::type type; -}; -#endif -#if RXCPP_USE_VARIADIC_TEMPLATES -template class Predicate, class Default, - class... ArgN> +template class Predicate, class Default, class... ArgN> auto resolve_arg(ArgN&&... an) -> typename arg_resolver::resolved_type { return arg_resolver::resolved_type::make(std::forward(an)...); } -#else -template class Predicate, class Default> -auto resolve_arg() --> decltype(typename arg_resolver::type::make(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type::make(tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); -} - -template class Predicate, class Default, - class Arg0> -auto resolve_arg(Arg0&& a0) --> decltype(typename arg_resolver::type::make(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type::make(std::forward(a0), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); -} - -template class Predicate, class Default, - class Arg0, class Arg1> -auto resolve_arg(Arg0&& a0, Arg1&& a1) --> decltype(typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), tag_unresolvable(), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); -} - -template class Predicate, class Default, - class Arg0, class Arg1, class Arg2> -auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2) --> decltype(typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), tag_unresolvable(), tag_unresolvable(), tag_unresolvable()); -} - -template class Predicate, class Default, - class Arg0, class Arg1, class Arg2, class Arg3> -auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) --> decltype(typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), tag_unresolvable(), tag_unresolvable())) { - return typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), tag_unresolvable(), tag_unresolvable()); -} - -template class Predicate, class Default, - class Arg0, class Arg1, class Arg2, class Arg3, class Arg4> -auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) --> decltype(typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), tag_unresolvable())) { - return typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), tag_unresolvable()); -} -template class Predicate, class Default, - class Arg0, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> -auto resolve_arg(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) --> decltype(typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))) { - return typename arg_resolver::type::make( - std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)); -} -#endif +template +struct tag_set {}; -struct arg_resolver_term {}; +template +struct arg_resolver_set; -// -// use to build a set of tags -// -template -struct tag_set +template +struct arg_resolver_set> { - typedef Tag tag; - typedef NextSet next_set; -}; + template + struct expand + { + typedef typename arg_resolver::resolved_type type; + }; -template -struct arg_resolver_set; + template + struct expanded; -template<> -struct arg_resolver_set -{ - inline std::tuple<> operator()(...){ - return std::tuple<>(); - } -}; + template + struct expanded> + { + template + static std::tuple make(ArgN&&... an) { + return std::tuple(Resolved0::make(std::forward(an)...)); + } + }; + + template + struct expanded> + { + typedef std::tuple result_type; + template + static result_type make(ArgN&&... an) { + return std::tuple_cat(std::tuple(Resolved0::make(std::forward(an)...)), expanded>::make(std::forward(an)...)); + } + }; -template -struct arg_resolver_set -{ - typedef typename TagSet::tag tag; - typedef arg_resolver_set next_set; -#if RXCPP_USE_VARIADIC_TEMPLATES template auto operator()(ArgN&&... an) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(an)...)), - next_set()(std::forward(an)...))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(an)...)), - next_set()(std::forward(an)...)); - } -#else - inline auto operator()() - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg()), - next_set()())) { - return std::tuple_cat( - std::make_tuple(resolve_arg()), - next_set()()); - } - template - auto operator()(Arg0&& a0) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0))), - next_set()(std::forward(a0)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0))), - next_set()(std::forward(a0))); - } - template - auto operator()(Arg0&& a0, Arg1&& a1) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), - next_set()(std::forward(a0), std::forward(a1)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1))), - next_set()(std::forward(a0), std::forward(a1))); - } - template - auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2))); + -> std::tuple< typename expand::type, + typename expand::type...> { + typedef std::tuple< typename expand::type, + typename expand::type...> out_type; + static_assert(std::tuple_size::value == (sizeof...(TagN) + 1), "tuple must have a value per tag"); + return expanded::make(std::forward(an)...); } - template - auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))); - } - template - auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))); - } - template - auto operator()(Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)))) { - return std::tuple_cat( - std::make_tuple(resolve_arg(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))), - next_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))); - } -#endif }; -#if RXCPP_USE_VARIADIC_TEMPLATES -template -inline std::tuple<> resolve_arg_set(arg_resolver_term&&, ArgN&&... ) { - return std::tuple<>(); -} - template -auto resolve_arg_set(TagSet&&, ArgN&&... an) - -> decltype(std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(an)...)), - resolve_arg_set(typename TagSet::next_set(), - std::forward(an)...))) { - return std::tuple_cat( - std::make_tuple(resolve_arg( - std::forward(an)...)), - resolve_arg_set(typename TagSet::next_set(), - std::forward(an)...)); -} -#else -template -auto resolve_arg_set(TagSet&&) - -> decltype(arg_resolver_set()()) { - return arg_resolver_set()(); -} -template -auto resolve_arg_set(TagSet&&, Arg0&& a0) - -> decltype(arg_resolver_set()(std::forward(a0))) { - return arg_resolver_set()(std::forward(a0)); -} -template -auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1) - -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1))) { - return arg_resolver_set()(std::forward(a0), std::forward(a1)); -} -template -auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2) - -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2))) { - return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2)); +auto resolve_arg_set(const TagSet&, ArgN&&... an) + -> decltype(arg_resolver_set()(std::forward(an)...)) { + return arg_resolver_set()(std::forward(an)...); } -template -auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3) - -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3))) { - return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3)); -} -template -auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4) - -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4))) { - return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4)); -} -template -auto resolve_arg_set(TagSet&&, Arg0&& a0, Arg1&& a1, Arg2&& a2, Arg3&& a3, Arg4&& a4, Arg5&& a5) - -> decltype(arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5))) { - return arg_resolver_set()(std::forward(a0), std::forward(a1), std::forward(a2), std::forward(a3), std::forward(a4), std::forward(a5)); -} -#endif } diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 9a7544a..6b5df0b 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -42,6 +42,12 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ { int c = 0; int n = 1; +#if 0 + auto onnext = [&c](int){++c;}; + auto onerror = [](std::exception_ptr){abort();}; + + auto oex = rxu::detail::arg_resolver_set::type>()(onnext, onerror); +#endif auto o = rx::make_observer( [&c](int){++c;}, [](std::exception_ptr){abort();}); @@ -77,6 +83,22 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ int c = 0; int n = 1; auto start = clock::now(); +#if 0 + auto rso = rxu::detail::arg_resolver_set::type>()( + [&c](int){ + ++c; + }, + [](std::exception_ptr){abort();}); + static_assert(std::tuple_size::value == 7, "object must resolve 7 args"); + auto rsf = rxu::detail::resolve_arg_set( + rx::detail::tag_subscriber_set::type(), + [&c](int){ + ++c; + }, + [](std::exception_ptr){abort();}); + static_assert(std::tuple_size::value == 7, "func must resolve 7 args"); + auto ss = rx::detail::make_subscriber_resolved(rsf); +#endif rxs::range(0, onnextcalls).subscribe( [&c](int){ ++c; -- GitLab From e9d750d9aca3bd907db58a41f349a2bdc8b3a386 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 27 Mar 2014 08:30:00 -0700 Subject: [PATCH 242/782] use perfect forwarding - duh --- Rx/v2/src/rxcpp/rx-observer.hpp | 26 ++++++++++++++----------- Rx/v2/src/rxcpp/rx-subscriber.hpp | 5 +++-- Rx/v2/src/rxcpp/rx-util.hpp | 4 ++-- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 5 +++-- 4 files changed, 23 insertions(+), 17 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index ec40195..4de5ffd 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -117,9 +117,10 @@ public: swap(oncompleted, o.oncompleted); } - void on_next(T t) const { + template + void on_next(V&& v) const { if (onnext) { - onnext(std::move(t)); + onnext(std::forward(v)); } } void on_error(std::exception_ptr e) const { @@ -182,8 +183,9 @@ public: swap(oncompleted, o.oncompleted); } - void on_next(T t) const { - onnext(std::move(t)); + template + void on_next(V&& v) const { + onnext(std::forward(v)); } void on_error(std::exception_ptr e) const { onerror(e); @@ -211,8 +213,9 @@ public: : inner(std::move(inner)) { } - void on_next(T t) const { - inner.on_next(std::move(t)); + template + void on_next(V&& v) const { + inner.on_next(std::forward(v)); } void on_error(std::exception_ptr e) const { inner.on_error(e); @@ -229,7 +232,8 @@ public: observer() { } - void on_next(T&&) const { + template + void on_next(V&&) const { } void on_error(std::exception_ptr) const { } @@ -277,9 +281,9 @@ struct resolved_observer_traits template struct static_observer_of { - typedef static_observer type; }; }; @@ -326,7 +330,7 @@ struct tag_oncompleted_resolution }; // types to disambiguate -// on_next and optional on_error, on_completed +// on_next and optional on_error, on_completed // template diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index d6a4deb..b9ff3e9 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -85,12 +85,13 @@ public: // observer // - void on_next(T t) const { + template + void on_next(V&& v) const { if (!is_subscribed()) { abort(); } detacher protect(this); - destination.on_next(std::move(t)); + destination.on_next(std::forward(v)); protect.that = nullptr; } void on_error(std::exception_ptr e) const { diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 6c7efa2..db964c5 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -139,7 +139,7 @@ public: if (is_set) { is_set = false; reinterpret_cast(&storage)->~T(); - std::fill_n(reinterpret_cast(&storage), sizeof(T), 0); + //std::fill_n(reinterpret_cast(&storage), sizeof(T), 0); } } @@ -331,7 +331,7 @@ struct arg_resolver_set> template struct expanded> { - typedef std::tuple result_type; + typedef std::tuple result_type; template static result_type make(ArgN&&... an) { return std::tuple_cat(std::tuple(Resolved0::make(std::forward(an)...)), expanded>::make(std::forward(an)...)); diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index a0b606f..85412e2 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -137,7 +137,8 @@ public: abort(); } } - void on_next(T t) const { + template + void on_next(V&& v) const { if (b->current_generation != b->state->generation) { std::unique_lock guard(b->state->lock); if (!b->completer) { @@ -151,7 +152,7 @@ public: } for (auto& o : b->current_completer->observers) { if (o.is_subscribed()) { - o.on_next(t); + o.on_next(std::forward(v)); } } } -- GitLab From 0286ccadc657eafdcaf61a10be1abc97f3e35c5d Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 27 Mar 2014 12:36:28 -0700 Subject: [PATCH 243/782] sometimes - don't use perfect forwarding --- Rx/v2/src/rxcpp/rx-util.hpp | 49 +++++++++++++++---------------------- 1 file changed, 20 insertions(+), 29 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index db964c5..9b0e98c 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -202,18 +202,18 @@ template struct select_arg { template - static auto get(GArg&&, GArgN&&... gan) - -> decltype(select_arg::get(std::forward(gan)...)) { - return select_arg::get(std::forward(gan)...); + static auto get(const GArg&, const GArgN&... gan) + -> decltype(select_arg::get(gan...)) { + return select_arg::get(gan...); } }; template struct select_arg { template - static auto get(GArg&& ga, GArgN&&...) - -> decltype(std::forward(ga)) { - return std::forward(ga); + static auto get(const GArg& ga, const GArgN&...) + -> decltype(ga) { + return ga; } }; @@ -227,13 +227,13 @@ struct resolved_arg result_type value; struct tag_value {}; template - resolved_arg(Value&& v, tag_value&&) - : value(std::forward(v)) + resolved_arg(const Value& v, tag_value&&) + : value(v) { } template - static this_type make(CArgN&&... can) { - return this_type(select_arg::get(std::forward(can)...), tag_value()); + static this_type make(const CArgN&... can) { + return this_type(select_arg::get(can...), tag_value()); } }; @@ -246,7 +246,7 @@ struct resolved_arg<-1, T> typedef T result_type; result_type value; template - static this_type make(CArgN&&... can) { + static this_type make(const CArgN&... can) { return this_type(); } }; @@ -295,10 +295,10 @@ struct arg_resolver }; template class Predicate, class Default, class... ArgN> -auto resolve_arg(ArgN&&... an) +auto resolve_arg(const ArgN&... an) -> typename arg_resolver::resolved_type { - return arg_resolver::resolved_type::make(std::forward(an)...); + return arg_resolver::resolved_type::make(an...); } template @@ -319,40 +319,31 @@ struct arg_resolver_set> template struct expanded; - template - struct expanded> - { - template - static std::tuple make(ArgN&&... an) { - return std::tuple(Resolved0::make(std::forward(an)...)); - } - }; - template struct expanded> { typedef std::tuple result_type; template - static result_type make(ArgN&&... an) { - return std::tuple_cat(std::tuple(Resolved0::make(std::forward(an)...)), expanded>::make(std::forward(an)...)); + static result_type make(const ArgN&... an) { + return result_type(Resolved0::make(an...), ResolvedN::make(an...)...); } }; template - auto operator()(ArgN&&... an) + auto operator()(const ArgN&... an) -> std::tuple< typename expand::type, typename expand::type...> { typedef std::tuple< typename expand::type, typename expand::type...> out_type; static_assert(std::tuple_size::value == (sizeof...(TagN) + 1), "tuple must have a value per tag"); - return expanded::make(std::forward(an)...); + return expanded::make(an...); } }; template -auto resolve_arg_set(const TagSet&, ArgN&&... an) - -> decltype(arg_resolver_set()(std::forward(an)...)) { - return arg_resolver_set()(std::forward(an)...); +auto resolve_arg_set(const TagSet&, const ArgN&... an) + -> decltype(arg_resolver_set()(an...)) { + return arg_resolver_set()(an...); } } -- GitLab From 7ad0f39a4a33e80071db74edc295ec049e4c0b0d Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sat, 29 Mar 2014 11:44:04 -0700 Subject: [PATCH 244/782] add some comments and remove redundant param --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 30 +++++++++++++++++-- .../src/rxcpp/schedulers/rx-currentthread.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 4 +-- 3 files changed, 31 insertions(+), 5 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index f92a981..c6069cf 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -23,6 +23,12 @@ typedef std::shared_ptr const_scheduler_interface_ptr } +// It is essential to keep virtual function calls out of an inner loop. +// To make tail-recursion work efficiently the recursion objects create +// a space on the stack inside the virtual function call in the actor that +// allows the callback and the scheduler to share stack space that records +// the request and the allowance without any virtual calls in the loop. + class recursed { bool& isrequested; @@ -270,6 +276,9 @@ class schedulable : public schedulable_base requestor = std::addressof(r.get_recursed()); return exit_recursed_scope_type(this); } + bool is_recursed() const { + return !!requestor; + } void operator()() const { (*requestor)(); } @@ -321,6 +330,17 @@ public: // recursed // + bool is_recursed() const { + return recursed_scope.is_recursed(); + } + /// requests tail-recursion of the same action + /// this will exit the process if called when + /// is_recursed() is false. + /// Note: to improve perf it is not required + /// to call is_recursed() before calling this + /// operator. Context is sufficient. The schedulable + /// passed to the action by the scheduler will return + /// true from is_recursed() inline void operator()() const { recursed_scope(); } @@ -351,27 +371,33 @@ public: inline clock_type::time_point now() const { return controller.now(); } + /// put this on the queue of the stored scheduler to run asap inline void schedule() const { controller.schedule(*this); } + /// put this on the queue of the stored scheduler to run after a delay from now inline void schedule(clock_type::duration when) const { controller.schedule(when, *this); } + /// put this on the queue of the stored scheduler to run at the specified time inline void schedule(clock_type::time_point when) const { controller.schedule(when, *this); } // action // + /// some schedulers care about how long an action will run + /// this is how an action declares its behavior inline action_duration::type get_duration() const { return activity.get_duration(); } - inline void operator()(const schedulable& scbl, const recurse& r) const { + /// + inline void operator()(const recurse& r) const { if (!is_subscribed()) { abort(); } detacher protect(this); - activity(scbl, r); + activity(*this, r); protect.that = nullptr; } }; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 72a8ab7..2384581 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -225,7 +225,7 @@ public: queue::pop(); - what(what, recursor); + what(recursor); if (queue::empty()) { break; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index 5d6c759..c162a02 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -79,7 +79,7 @@ public: if (next.when > clock_now) { clock_now = next.when; } - next.what(next.what, r.get_recurse()); + next.what(r.get_recurse()); } else { isenabled = false; @@ -240,7 +240,7 @@ protected: r.reset(false); if (scbl.is_subscribed()) { scbl.unsubscribe(); // unsubscribe() run, not a; - a(a, r.get_recurse()); + a(r.get_recurse()); } }); queue.push(item_type(when, run)); -- GitLab From 267228d08d0e4917664b2ff82409431a98213546 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sat, 29 Mar 2014 16:08:12 -0700 Subject: [PATCH 245/782] reimplement make_subscriber the verbose way --- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 18 +- Rx/v2/src/rxcpp/rx-observable.hpp | 18 +- Rx/v2/src/rxcpp/rx-observer.hpp | 193 ++++----- Rx/v2/src/rxcpp/rx-subscriber.hpp | 484 ++++++++++++++++------ projects/CMake/CMakeLists.txt | 4 +- 5 files changed, 477 insertions(+), 240 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 554ea15..b426a6b 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -31,9 +31,9 @@ struct flat_map_traits { typedef decltype((*(collection_selector_type*)nullptr)((*(source_value_type*)nullptr))) collection_type; -#if _MSC_VER >= 1900 +//#if _MSC_VER >= 1900 static_assert(is_observable::value, "flat_map CollectionSelector must return an observable"); -#endif +//#endif typedef typename collection_type::value_type collection_value_type; @@ -81,11 +81,11 @@ struct flat_map { } - template - void on_subscribe(Observer&& o) { - static_assert(is_observer::value, "subscribe must be passed an observer"); + template + void on_subscribe(Subscriber&& scbr) { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename std::decay::type output_type; + typedef typename std::decay::type output_type; struct state_type : public std::enable_shared_from_this @@ -108,7 +108,7 @@ struct flat_map output_type out; }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::forward(o))); + auto state = std::shared_ptr(new state_type(initial, std::forward(scbr))); composite_subscription outercs; @@ -120,7 +120,7 @@ struct flat_map // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - state->source.subscribe( + state->source.subscribe(make_subscriber_cs5( state->out, outercs, // on_next @@ -189,7 +189,7 @@ struct flat_map state->out.on_completed(); } } - ); + )); } }; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 2b59544..bac30b1 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -244,9 +244,9 @@ public: /// template auto filter(Predicate&& p) const - -> observable> { - return observable>( - rxo::detail::filter(*this, std::forward(p))); + -> observable> { + return observable>( + rxo::detail::filter(*this, std::forward(p))); } /// map (AKA Select) -> @@ -254,9 +254,9 @@ public: /// template auto map(Selector&& s) const - -> observable::value_type, rxo::detail::map> { - return observable::value_type, rxo::detail::map>( - rxo::detail::map(*this, std::forward(s))); + -> observable::value_type, rxo::detail::map> { + return observable::value_type, rxo::detail::map>( + rxo::detail::map(*this, std::forward(s))); } /// flat_map (AKA SelectMany) -> @@ -265,9 +265,9 @@ public: /// template auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::flat_map> { - return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); + -> observable::value_type, rxo::detail::flat_map> { + return observable::value_type, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); } /// diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 4de5ffd..74946e8 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -72,7 +72,7 @@ struct is_on_completed } template -class dynamic_observer : public observer_base +class dynamic_observer { public: typedef tag_dynamic_observer dynamic_observer_tag; @@ -135,8 +135,8 @@ public: } }; -template -class static_observer : public observer_base +template +class static_observer { public: typedef static_observer this_type; @@ -154,7 +154,7 @@ public: static_assert(detail::is_on_error::value, "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); static_assert(detail::is_on_completed::value, "Function supplied for on_completed must be a function with the signature void();"); - explicit static_observer(on_next_t n, on_error_t e, on_completed_t c) + explicit static_observer(on_next_t n, on_error_t e = on_error_t(), on_completed_t c = on_completed_t()) : onnext(std::move(n)) , onerror(std::move(e)) , oncompleted(std::move(c)) @@ -199,7 +199,7 @@ template class observer : public observer_base { typedef observer this_type; - typedef typename std::conditional::value, typename std::decay::type, dynamic_observer>::type inner_t; + typedef typename std::decay::type inner_t; inner_t inner; public: @@ -247,111 +247,102 @@ auto make_observer() return observer(); } -namespace detail { - -template -auto make_observer_resolved_explicit(ResolvedArgSet&& rs) +template +auto make_observer(const observer& o) -> observer { - typedef I inner_type; - return observer(inner_type( - std::move(std::get<0>(std::forward(rs)).value), - std::move(std::get<1>(std::forward(rs)).value), - std::move(std::get<2>(std::forward(rs)).value))); - - typedef typename std::decay(std::forward(rs)))>::type rn_t; - typedef typename std::decay(std::forward(rs)))>::type re_t; - typedef typename std::decay(std::forward(rs)))>::type rc_t; - - static_assert(rn_t::is_arg, "onnext is a required parameter"); - static_assert(!(rn_t::is_arg && re_t::is_arg) || rn_t::n + 1 == re_t::n, "onnext, onerror parameters must be together and in order"); - static_assert(!(re_t::is_arg && rc_t::is_arg) || re_t::n + 1 == rc_t::n, "onerror, oncompleted parameters must be together and in order"); - static_assert(!(rn_t::is_arg && rc_t::is_arg && !re_t::is_arg) || rn_t::n + 1 == rc_t::n, "onnext, oncompleted parameters must be together and in order"); + return observer( + I(o)); } -template -struct resolved_observer_traits -{ - typedef typename std::decay::type resolved_set; - - static_assert(std::tuple_size::value >= 3, "must have at least three resolved arguments"); - - typedef typename std::tuple_element<0, resolved_set>::type resolved_on_next; - typedef typename std::tuple_element<1, resolved_set>::type resolved_on_error; - typedef typename std::tuple_element<2, resolved_set>::type resolved_on_completed; - - template - struct static_observer_of - { - typedef static_observer type; - }; -}; -template -auto make_observer_resolved(ResolvedArgSet&& rs) - -> observer::template static_observer_of::type> { - return make_observer_resolved_explicit::template static_observer_of::type>(std::forward(rs)); +template +auto make_observer(observer&& o) + -> observer { + return observer( + I(std::move(o))); +} +template +auto make_observer(const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + observer>>::type { + return observer>( + static_observer(on)); +} +template +auto make_observer(const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + observer>>::type { + return observer>( + static_observer(on, oe)); +} +template +auto make_observer(const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + observer>>::type { + return observer>( + static_observer(on, detail::OnErrorEmpty(), oc)); } -template -auto make_observer_dynamic_resolved(ResolvedArgSet&& rs) - -> observer> { - return make_observer_resolved_explicit>(std::forward(rs)); +template +auto make_observer(const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + observer>>::type { + return observer>( + static_observer(on, oe, oc)); } template -struct tag_onnext_resolution -{ - template - struct predicate - { - static const bool value = is_on_next_of::value; - }; - typedef OnNextEmpty default_type; -}; - -struct tag_onerror_resolution -{ - template - struct predicate - { - static const bool value = is_on_error::value; - }; - typedef OnErrorEmpty default_type; -}; - -struct tag_oncompleted_resolution -{ - template - struct predicate - { - static const bool value = is_on_completed::value; - }; - typedef OnCompletedEmpty default_type; -}; - -// types to disambiguate -// on_next and optional on_error, on_completed -// - +auto make_observer_dynamic(const observer& o) + -> observer { + return observer( + dynamic_observer(o)); +} template -struct tag_observer_set -{ - typedef rxu::detail::tag_set, tag_onerror_resolution, tag_oncompleted_resolution> type; -}; - - +auto make_observer_dynamic(observer&& o) + -> observer { + return observer( + dynamic_observer(std::move(o))); } - -template -auto make_observer(Arg0&& a0, ArgN&&... an) - -> decltype(detail::make_observer_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...))) { - return detail::make_observer_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...)); +template +auto make_observer_dynamic(OnNext&& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + observer>>::type { + return observer>( + dynamic_observer(std::forward(on), nullptr, nullptr)); } - -template -auto make_observer_dynamic(Arg0&& a0, ArgN&&... an) - -> decltype(detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...))) { - return detail::make_observer_dynamic_resolved(rxu::detail::resolve_arg_set(typename detail::tag_observer_set::type(), std::forward(a0), std::forward(an)...)); +template +auto make_observer_dynamic(OnNext&& on, OnError&& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + observer>>::type { + return observer>( + dynamic_observer(std::forward(on), std::forward(oe), nullptr)); +} +template +auto make_observer_dynamic(OnNext&& on, OnCompleted&& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + observer>>::type { + return observer>( + dynamic_observer(std::forward(on), nullptr, std::forward(oc))); +} +template +auto make_observer_dynamic(OnNext&& on, OnError&& oe, OnCompleted&& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + observer>>::type { + return observer>( + dynamic_observer(std::forward(on), std::forward(oe), std::forward(oc))); } } diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index b9ff3e9..65cbfde 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -132,137 +132,383 @@ public: }; -namespace detail { - -template -struct observer_selector; - -template -struct observer_selector -{ - template - static auto get_observer(Set& rs) - -> decltype(std::get<5>(rs).value) { - return std::get<5>(rs).value; - } -}; -template -struct observer_selector -{ - template - static auto get_observer(Set& rs) - -> decltype(make_observer_resolved(rs)) { - return make_observer_resolved(rs); - } -}; -template -struct observer_selector -{ - template - static auto get_observer(Set& rs) - -> decltype( std::get<6>(rs).value.get_observer()) { - return std::get<6>(rs).value.get_observer(); - } -}; - -template -auto select_observer(ResolvedArgSet& rs) - -> decltype(observer_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs)) { - return observer_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_observer(rs); - - typedef typename std::decay(std::forward(rs)))>::type rr_t; - typedef typename std::decay(std::forward(rs)))>::type rn_t; - typedef typename std::decay(std::forward(rs)))>::type re_t; - typedef typename std::decay(std::forward(rs)))>::type rc_t; - typedef typename std::decay(std::forward(rs)))>::type ro_t; - typedef typename std::decay(std::forward(rs)))>::type rs_t; - - static_assert(rs_t::is_arg || ro_t::is_arg || rn_t::is_arg, "at least one of; onnext, observer or subscriber is required"); - static_assert(int(ro_t::is_arg) + int(rn_t::is_arg) < 2, "onnext, onerror and oncompleted not allowed with an observer"); +// copy +template +auto make_subscriber( + const subscriber& o) + -> subscriber { + return subscriber(o); } - -template -auto make_subscriber_resolved(ResolvedArgSet&& rsArg) - -> subscriber(*(typename std::decay::type*)nullptr))> { - const auto rs = std::forward(rsArg); - const auto rsub = std::get<3>(rs); - const auto rr = std::get<4>(rs); - const auto rscrbr = std::get<6>(rs); - const auto r = (rscrbr.is_arg && !rr.is_arg) ? rscrbr.value.get_resumption() : rr.value; - const auto s = (rscrbr.is_arg && !rsub.is_arg) ? rscrbr.value.get_subscription() : rsub.value; - return subscriber(*(typename std::decay::type*)nullptr))>( - s, r, select_observer(rs)); - - static_assert(std::tuple_size::value == 7, "must have 7 resolved args"); -// at least for now do not enforce resolver -#if 0 - typedef typename std::decay::type rr_t; - typedef typename std::decay::type rs_t; - - static_assert(rs_t::is_arg || rr_t::is_arg, "at least one of; resumption or subscriber is a required parameter"); -#endif +// move +template +auto make_subscriber( + subscriber&& o) + -> subscriber { + return subscriber(std::move(o)); } -template -struct tag_subscriber_resolution -{ - template - struct predicate : public is_subscriber - { - }; - typedef subscriber> default_type; -}; +// observer +// -template -struct tag_observer_resolution -{ - template - struct predicate - { - static const bool value = !is_subscriber::value && is_observer::value; - }; - typedef observer default_type; -}; +template +auto make_subscriber( + const observer& o) + -> subscriber> { + return subscriber>(composite_subscription(), resumption(), o); +} +template +auto make_subscriber(const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(composite_subscription(), resumption(), o); +} +template +auto make_subscriber(const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), resumption(), + observer>( + static_observer>(on))); +} +template +auto make_subscriber(const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), resumption(), + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), resumption(), + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), resumption(), + observer>( + static_observer(on, oe, oc))); +} -struct tag_resumption_resolution -{ - template - struct predicate - { - static const bool value = !is_subscriber::value && is_resumption::value; - }; - typedef resumption default_type; -}; +// explicit lifetime +// +template +auto make_subscriber(const composite_subscription& cs, + const observer& o) + -> subscriber> { + return subscriber>(cs, resumption(), o); +} +template +auto make_subscriber(const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(cs, resumption(), o); +} +template +auto make_subscriber(const composite_subscription& cs, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(cs, resumption(), + observer>( + static_observer(on))); +} +template +auto make_subscriber(const composite_subscription& cs, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(cs, resumption(), + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(const composite_subscription& cs, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(cs, resumption(), + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(cs, resumption(), + observer>( + static_observer(on, oe, oc))); +} +template +auto make_subscriber(const resumption& r, + const observer& o) + -> subscriber> { + return subscriber>(composite_subscription(), r, o); +} +template +auto make_subscriber(const resumption& r, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(composite_subscription(), r, o); +} +template +auto make_subscriber(const resumption& r, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), r, + observer>( + static_observer(on))); +} +template +auto make_subscriber(const resumption& r, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), r, + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(const resumption& r, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), r, + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(const resumption& r, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(composite_subscription(), r, + observer>( + static_observer(on, oe, oc))); +} -// types to disambiguate -// subscriber with override for subscription, observer, resumption | -// optional subscriber + -// observer | on_next and optional on_error, on_completed + -// resumption + -// subscription | unsubscribe +// chain defaults from subscriber // +template +auto make_subscriber(const subscriber& scbr, + const observer& o) + -> subscriber> { + return subscriber>(scbr.get_subscription(), scbr.get_resumption(), o); +} +template +auto make_subscriber(const subscriber& scbr, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(scbr.get_subscription(), scbr.get_resumption(), o); +} +template +auto make_subscriber(const subscriber& scbr, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + observer>( + static_observer(on))); +} +template +auto make_subscriber(const subscriber& scbr, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(const subscriber& scbr, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(const subscriber& scbr, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + observer>( + static_observer(on, oe, oc))); +} -template -struct tag_subscriber_set -{ - // the first four must be the same as tag_observer_set or the indexing will fail - typedef rxu::detail::tag_set< - tag_onnext_resolution, - tag_onerror_resolution, - tag_oncompleted_resolution, - tag_subscription_resolution, - tag_resumption_resolution, - tag_observer_resolution, - tag_subscriber_resolution> type; -}; +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, + const observer& o) + -> subscriber> { + return subscriber>(cs, scbr.get_resumption(), o); +} +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(cs, scbr.get_resumption(), o); +} +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(cs, scbr.get_resumption(), + observer>( + static_observer(on))); +} +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(cs, scbr.get_resumption(), + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(cs, scbr.get_resumption(), + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(cs, scbr.get_resumption(), + observer>( + static_observer(on, oe, oc))); +} +template +auto make_subscriber_cs5(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(cs, scbr.get_resumption(), + observer>( + static_observer(on, oe, oc))); +} +template +auto make_subscriber(const subscriber& scbr, const resumption& r, + const observer& o) + -> subscriber> { + return subscriber>(scbr.get_subscription(), r, o); +} +template +auto make_subscriber(const subscriber& scbr, const resumption& r, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(scbr.get_subscription(), r, o); +} +template +auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), r, + observer>( + static_observer(on))); +} +template +auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), r, + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), r, + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(scbr.get_subscription(), r, + observer>( + static_observer(on, oe, oc))); } -template -auto make_subscriber(Arg0&& a0, ArgN&&... an) - -> decltype(detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(typename detail::tag_subscriber_set::type(), std::forward(a0), std::forward(an)...))) { - return detail::make_subscriber_resolved(rxu::detail::resolve_arg_set(typename detail::tag_subscriber_set::type(), std::forward(a0), std::forward(an)...)); +// override lifetime +// +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs) + -> subscriber { + return subscriber(cs, scbr.get_resumption(), scbr.get_observer()); +} +// override back-pressure +// +template +auto make_subscriber(const subscriber& scbr, const resumption& r) + -> subscriber { + return subscriber(scbr.get_subscription(), r, scbr.get_observer()); +} +// only keep observer +// +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const resumption& r) + -> subscriber { + return subscriber(cs, r, scbr.get_observer()); } } diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 74cfc08..11447e4 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,10 +42,10 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp - ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp - ${V2_TEST_DIR}/operators/flat_map.cpp + ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/subscription.cpp + ${V2_TEST_DIR}/operators/flat_map.cpp ${V2_TEST_DIR}/operators/filter.cpp ${V2_TEST_DIR}/operators/map.cpp ) -- GitLab From 282d43a2f33e914c4226dc6184fcc4ef93a0cd5b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Sat, 29 Mar 2014 17:57:14 -0700 Subject: [PATCH 246/782] remove resolve_arg library --- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 4 +- Rx/v2/src/rxcpp/rx-observable.hpp | 2 +- Rx/v2/src/rxcpp/rx-scheduler.hpp | 258 ++++++++-------------- Rx/v2/src/rxcpp/rx-subscriber.hpp | 11 - Rx/v2/src/rxcpp/rx-util.hpp | 148 ------------- Rx/v2/src/rxcpp/sources/rx-range.hpp | 34 +-- 6 files changed, 112 insertions(+), 345 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index b426a6b..38dd15f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -120,7 +120,7 @@ struct flat_map // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - state->source.subscribe(make_subscriber_cs5( + state->source.subscribe( state->out, outercs, // on_next @@ -189,7 +189,7 @@ struct flat_map state->out.on_completed(); } } - )); + ); } }; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index bac30b1..8282ea2 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -169,7 +169,7 @@ private: // make sure to let current_thread take ownership of the thread as early as possible. if (rxsc::current_thread::is_schedule_required()) { auto sc = rxsc::make_current_thread(); - schedule(sc, [=](const rxsc::schedulable& scbl) { + sc.schedule(o.get_subscription(), [=](const rxsc::schedulable& scbl) { safe_subscribe(); }); } else { diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index c6069cf..b323449 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -169,6 +169,22 @@ inline bool operator!=(const action& lhs, const action& rhs) { return !(lhs == rhs); } +namespace detail { + +template +struct is_action_function +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)(*(schedulable*)nullptr)); + template + static not_void check(...); + + static const bool value = std::is_same::type>(0)), void>::value; +}; + +} + class scheduler : public scheduler_base { typedef scheduler this_type; @@ -202,6 +218,20 @@ public: inline void schedule(clock_type::time_point when, const schedulable& scbl) const { inner->schedule(when, scbl); } + + template + auto schedule(Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type; + template + auto schedule(Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + !detail::is_action_function::value && + !is_subscription::value && + !is_scheduler::value && + !is_schedulable::value>::type; }; inline bool operator==(const scheduler& lhs, const scheduler& rhs) { @@ -471,6 +501,7 @@ inline action make_action_empty() { template inline action make_action(F&& f, action_duration::type d = action_duration::runs_short) { + static_assert(detail::is_action_function::value, "action function must be void(schedulable)"); auto fn = std::forward(f); return action(std::make_shared( d, @@ -491,184 +522,77 @@ inline action make_action(F&& f, action_duration::type d = action_duration::runs })); } -namespace detail { - -template -struct is_action_function -{ - struct not_void {}; - template - static auto check(int) -> decltype((*(CF*)nullptr)(*(schedulable*)nullptr)); - template - static not_void check(...); - - static const bool value = std::is_same::type>(0)), void>::value; -}; - -struct tag_action_function_resolution -{ - template - struct predicate - { - static const bool value = is_action_function::value; - }; - typedef detail::action_type::function_type default_type; -}; - -struct tag_action_duration_resolution -{ - template - struct predicate - { - static const bool value = std::is_same::type, action_duration::type>::value; - }; - struct default_type { - inline operator action_duration::type() const { - return action_duration::runs_short; - } - }; -}; - -struct tag_when_resolution -{ - typedef scheduler_interface::clock_type clock_type; - typedef clock_type::duration duration_type; - typedef clock_type::time_point time_point_type; - template - struct predicate - { - typedef typename std::decay::type decayedlhs; - static const bool value = std::is_same::value || - std::is_same::value; - }; - struct default_type { - inline operator time_point_type() const { - return clock_type::now(); - } - }; -}; - -struct tag_schedulable_resolution -{ - template - struct predicate : public is_schedulable - { - }; - typedef schedulable default_type; -}; - -struct tag_action_resolution -{ - template - struct predicate - { - static const bool value = !is_schedulable::value && is_action::value; - }; - typedef action default_type; -}; - -struct tag_scheduler_resolution -{ - template - struct predicate - { - static const bool value = !is_schedulable::value && is_scheduler::value; - }; - typedef scheduler default_type; -}; - - -typedef rxu::detail::tag_set tag_schedulable_set; - -template -struct action_selector; - -template -struct action_selector -{ - template - static action get_action(Set& rs) { - return std::get<4>(rs).value; - } -}; -template -struct action_selector -{ - template - static action get_action(Set& rs) { - return make_action(std::get<5>(rs).value, std::get<6>(rs).value); - } -}; -template<> -struct action_selector -{ - template - static action get_action(Set& rs) { - return std::get<1>(rs).value.get_action(); - } -}; - -template -action select_action(ResolvedArgSet& rs) { - return action_selector(rs))>::type::is_arg, std::decay(rs))>::type::is_arg, std::decay(rs))>::type::is_arg>::get_action(rs); +// copy +inline auto make_schedulable( + const schedulable& scbl) + -> schedulable { + return schedulable(scbl); +} +// move +inline auto make_schedulable( + schedulable&& scbl) + -> schedulable { + return schedulable(std::move(scbl)); +} - typedef typename std::decay(std::forward(rs)))>::type rsc_t; - typedef typename std::decay(std::forward(rs)))>::type raf_t; - typedef typename std::decay(std::forward(rs)))>::type rad_t; - typedef typename std::decay(std::forward(rs)))>::type ra_t; - typedef typename std::decay(std::forward(rs)))>::type rscbl_t; +// action +// - static_assert(rscbl_t::is_arg || ra_t::is_arg || raf_t::is_arg, "at least one of; action_function, action or schedulable is required"); - static_assert(int(ra_t::is_arg) + int(raf_t::is_arg) < 2, "action_function not allowed with an action"); - static_assert(int(ra_t::is_arg) + int(rad_t::is_arg) < 2, "action_duration not allowed with an action"); +template +auto make_schedulable(scheduler sc, F&& f, action_duration::type d = action_duration::runs_short) + -> typename std::enable_if::value, schedulable>::type { + return schedulable(composite_subscription(), sc, make_action(std::forward(f), d)); } - -template -schedulable make_schedulable_resolved(ResolvedArgSet&& rsArg) { - const auto rs = std::forward(rsArg); - const auto rsub = std::get<2>(rs); - const auto rsc = std::get<3>(rs); - const auto rscbl = std::get<1>(rs); - const auto sc = (rscbl.is_arg && !rsc.is_arg) ? rscbl.value.get_scheduler() : rsc.value; - const auto sub = (rscbl.is_arg && !rsub.is_arg) ? rscbl.value.get_subscription() : rsub.value; - return schedulable(sub, sc, select_action(rs)); - - typedef typename std::decay(rs))>::type rw_t; - typedef typename std::decay(rs))>::type rsc_t; - typedef typename std::decay(rs))>::type rscbl_t; - - static_assert(when_invalid || !rw_t::is_arg, "when is an invalid parameter"); - static_assert(rscbl_t::is_arg || rsc_t::is_arg, "at least one of; scheduler or schedulable is required"); +template +auto make_schedulable(scheduler sc, composite_subscription cs, F&& f, action_duration::type d = action_duration::runs_short) + -> typename std::enable_if::value, schedulable>::type { + return schedulable(cs, sc, make_action(std::forward(f), d)); } - -template -schedulable schedule_resolved(ResolvedArgSet&& rsArg) { - const auto rw = std::get<0>(rsArg); - schedulable result = make_schedulable_resolved(std::forward(rsArg)); - if (rw.is_arg) { - result.schedule(rw.value); - } else { - result.schedule(); - } - return result; +template +auto make_schedulable(schedulable scbl, composite_subscription cs, F&& f, action_duration::type d = action_duration::runs_short) + -> typename std::enable_if::value, schedulable>::type { + return schedulable(cs, scbl.get_scheduler(), make_action(std::forward(f), d)); +} +template +auto make_schedulable(schedulable scbl, scheduler sc, F&& f, action_duration::type d = action_duration::runs_short) + -> typename std::enable_if::value, schedulable>::type { + return schedulable(scbl.get_subscription(), sc, make_action(std::forward(f), d)); +} +template +auto make_schedulable(schedulable scbl, F&& f, action_duration::type d = action_duration::runs_short) + -> typename std::enable_if::value, schedulable>::type { + return schedulable(scbl.get_subscription(), scbl.get_scheduler(), make_action(std::forward(f), d)); } +inline auto make_schedulable(schedulable scbl, composite_subscription cs) + -> schedulable { + return schedulable(cs, scbl.get_scheduler(), scbl.get_action()); +} +inline auto make_schedulable(schedulable scbl, scheduler sc, composite_subscription cs) + -> schedulable { + return schedulable(cs, sc, scbl.get_action()); +} +inline auto make_schedulable(schedulable scbl, scheduler sc) + -> schedulable { + return schedulable(composite_subscription(), sc, scbl.get_action()); } template -schedulable make_schedulable(Arg0&& a0, ArgN&&... an) { - return detail::make_schedulable_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); +auto scheduler::schedule(Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type { + return this->schedule(make_schedulable(*this, std::forward(a0), std::forward(an)...)); } - template -schedulable schedule(Arg0&& a0, ArgN&&... an) { - return detail::schedule_resolved(rxu::detail::resolve_arg_set(detail::tag_schedulable_set(), std::forward(a0), std::forward(an)...)); +auto scheduler::schedule(Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + !detail::is_action_function::value && + !is_subscription::value && + !is_scheduler::value && + !is_schedulable::value>::type { + return this->schedule(std::forward(a0), make_schedulable(*this, std::forward(an)...)); } namespace detail { diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 65cbfde..3cb1e60 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -423,17 +423,6 @@ auto make_subscriber(const subscriber& scbr, const compos observer>( static_observer(on, oe, oc))); } -template -auto make_subscriber_cs5(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_error::value && - detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(cs, scbr.get_resumption(), - observer>( - static_observer(on, oe, oc))); -} template auto make_subscriber(const subscriber& scbr, const resumption& r, diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 9b0e98c..6e7db79 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -198,154 +198,6 @@ private: Function* function; }; -template -struct select_arg -{ - template - static auto get(const GArg&, const GArgN&... gan) - -> decltype(select_arg::get(gan...)) { - return select_arg::get(gan...); - } -}; -template -struct select_arg -{ - template - static auto get(const GArg& ga, const GArgN&...) - -> decltype(ga) { - return ga; - } -}; - -template -struct resolved_arg -{ - typedef resolved_arg this_type; - static const int n = N; - static const bool is_arg = true; - typedef T result_type; - result_type value; - struct tag_value {}; - template - resolved_arg(const Value& v, tag_value&&) - : value(v) - { - } - template - static this_type make(const CArgN&... can) { - return this_type(select_arg::get(can...), tag_value()); - } -}; - -template -struct resolved_arg<-1, T> -{ - typedef resolved_arg<-1, T> this_type; - static const int n = -1; - static const bool is_arg = false; - typedef T result_type; - result_type value; - template - static this_type make(const CArgN&... can) { - return this_type(); - } -}; - - -template -struct select_first; - -template -struct select_first -{ - static const int value = Predicate0 ? N : select_first::value; -}; -template -struct select_first -{ - static const int value = -1; -}; - -template -struct select_n -{ - struct type; -}; - -template -struct select_n : public select_n -{ -}; - -template -struct select_n -{ - typedef SArg0 type; -}; - -template class Predicate, class Default, class... ArgN> -struct arg_resolver -{ - typedef select_first<0, Predicate::value...> match; - typedef typename std::conditional< - match::value != -1, - typename select_n::type, - Default>::type result_type; - typedef resolved_arg resolved_type; -}; - -template class Predicate, class Default, class... ArgN> -auto resolve_arg(const ArgN&... an) --> typename arg_resolver::resolved_type -{ - return arg_resolver::resolved_type::make(an...); -} - -template -struct tag_set {}; - -template -struct arg_resolver_set; - -template -struct arg_resolver_set> -{ - template - struct expand - { - typedef typename arg_resolver::resolved_type type; - }; - - template - struct expanded; - - template - struct expanded> - { - typedef std::tuple result_type; - template - static result_type make(const ArgN&... an) { - return result_type(Resolved0::make(an...), ResolvedN::make(an...)...); - } - }; - - template - auto operator()(const ArgN&... an) - -> std::tuple< typename expand::type, - typename expand::type...> { - typedef std::tuple< typename expand::type, - typename expand::type...> out_type; - static_assert(std::tuple_size::value == (sizeof...(TagN) + 1), "tuple must have a value per tag"); - return expanded::make(an...); - } -}; - -template -auto resolve_arg_set(const TagSet&, const ArgN&... an) - -> decltype(arg_resolver_set()(an...)) { - return arg_resolver_set()(an...); -} - } } diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index de4b753..69d5984 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -34,24 +34,26 @@ struct range : public source_base template void on_subscribe(Subscriber o) { auto state = std::make_shared(init); - schedule(state->sc, o.get_subscription(), [=](const rxsc::schedulable& self){ - if (state->remaining == 0) { - o.on_completed(); - // o is unsubscribed - } - if (!o.is_subscribed()) { - // terminate loop - return; - } + state->sc.schedule( + o.get_subscription(), + [=](const rxsc::schedulable& self){ + if (state->remaining == 0) { + o.on_completed(); + // o is unsubscribed + } + if (!o.is_subscribed()) { + // terminate loop + return; + } - // send next value - --state->remaining; - o.on_next(state->next); - state->next = static_cast(state->step + state->next); + // send next value + --state->remaining; + o.on_next(state->next); + state->next = static_cast(state->step + state->next); - // tail recurse this same action to continue loop - self(); - }); + // tail recurse this same action to continue loop + self(); + }); } }; -- GitLab From 142b59871330dd34a6c49d70b802d5baf833e7a0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 29 Mar 2014 18:06:15 -0700 Subject: [PATCH 247/782] clang caught a typo --- Rx/v2/src/rxcpp/rx-subscriber.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 3cb1e60..fbf04be 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -170,7 +170,7 @@ auto make_subscriber(const OnNext& on) subscriber>>>::type { return subscriber>>(composite_subscription(), resumption(), observer>( - static_observer>(on))); + static_observer(on))); } template auto make_subscriber(const OnNext& on, const OnError& oe) -- GitLab From 61e08eb09b856e63bea069e548de75aa87770d38 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 3 Apr 2014 16:27:00 -0700 Subject: [PATCH 248/782] split out the perf tests --- Rx/v2/test/subjects/subject.cpp | 209 ++++++++++++++++++-------------- 1 file changed, 121 insertions(+), 88 deletions(-) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 6b5df0b..f765f03 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -16,99 +16,121 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -SCENARIO("subject test", "[hide][subject][subjects][perf]"){ - GIVEN("a subject"){ - WHEN("multicasting a million ints"){ +const int static_onnextcalls = 100000000; + +SCENARIO("for loop locks mutex", "[hide][for][mutex][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop"){ + WHEN("locking mutex 100 million times"){ using namespace std::chrono; typedef steady_clock clock; - const int onnextcalls = 100000000; - - { - std::mutex m; - int c = 0; - int n = 1; - auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { - std::unique_lock guard(m); - ++c; - } - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + int c = 0; + int n = 1; + auto start = clock::now(); + std::mutex m; + for (int i = 0; i < onnextcalls; i++) { + std::unique_lock guard(m); + ++c; } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - { - int c = 0; - int n = 1; -#if 0 - auto onnext = [&c](int){++c;}; - auto onerror = [](std::exception_ptr){abort();}; + } + } +} - auto oex = rxu::detail::arg_resolver_set::type>()(onnext, onerror); -#endif - auto o = rx::make_observer( - [&c](int){++c;}, - [](std::exception_ptr){abort();}); - auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { - o.on_next(i); - } - o.on_completed(); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "loop -> observer : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; - } +int aliased = 0; - { - int c = 0; - int n = 1; - auto o = rx::make_observer( - [&c](int){++c;}, - [](std::exception_ptr){abort();}); - auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { - o.on_next(i); - } - o.on_completed(); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "loop -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; +SCENARIO("for loop calls observer", "[hide][for][observer][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop"){ + WHEN("observing 100 million ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + int& c = aliased; + int n = 1; + + c = 0; + auto start = clock::now(); + auto o = rx::make_observer( + [&c](int){++c;}, + [](std::exception_ptr){abort();}); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); } + o.on_completed(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop -> observer : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} - { - int c = 0; - int n = 1; - auto start = clock::now(); -#if 0 - auto rso = rxu::detail::arg_resolver_set::type>()( - [&c](int){ - ++c; - }, - [](std::exception_ptr){abort();}); - static_assert(std::tuple_size::value == 7, "object must resolve 7 args"); - auto rsf = rxu::detail::resolve_arg_set( - rx::detail::tag_subscriber_set::type(), - [&c](int){ - ++c; - }, - [](std::exception_ptr){abort();}); - static_assert(std::tuple_size::value == 7, "func must resolve 7 args"); - auto ss = rx::detail::make_subscriber_resolved(rsf); -#endif - rxs::range(0, onnextcalls).subscribe( - [&c](int){ - ++c; - }, - [](std::exception_ptr){abort();}); - auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); - std::cout << "range -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; +SCENARIO("for loop calls subscriber", "[hide][for][subscriber][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop"){ + WHEN("observing 100 million ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + int& c = aliased; + int n = 1; + + c = 0; + auto start = clock::now(); + auto o = rx::make_subscriber( + [&c](int){++c;}, + [](std::exception_ptr){abort();}); + for (int i = 0; i < onnextcalls; i++) { + o.on_next(i); } + o.on_completed(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "loop -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + +SCENARIO("range calls subscriber", "[hide][range][subscriber][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a range"){ + WHEN("observing 100 million ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + int& c = aliased; + int n = 1; + + c = 0; + auto start = clock::now(); + + rxs::range(0, onnextcalls).subscribe( + [&c](int){ + ++c; + }, + [](std::exception_ptr){abort();}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "range -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + +SCENARIO("for loop calls subject", "[hide][for][subject][subjects][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop and a subject"){ + WHEN("multicasting a million ints"){ + using namespace std::chrono; + typedef steady_clock clock; for (int n = 0; n < 10; n++) { @@ -134,10 +156,13 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ while(o.is_subscribed()) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); rx::composite_subscription cs; - source.subscribe(cs, [cs](int){ - cs.unsubscribe(); - }, - [](std::exception_ptr){abort();}); + source.subscribe( + rx::make_subscriber( + cs, + [cs](int){ + cs.unsubscribe(); + }, + [](std::exception_ptr){abort();})); } return 0; }); @@ -163,7 +188,16 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ duration_cast(start.time_since_epoch()); std::cout << "loop -> subject : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } + } + } +} +SCENARIO("range calls subject", "[hide][range][subject][subjects][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a range and a subject"){ + WHEN("multicasting a million ints"){ + using namespace std::chrono; + typedef steady_clock clock; for (int n = 0; n < 10; n++) { auto p = std::make_shared(0); @@ -224,7 +258,6 @@ SCENARIO("subject test", "[hide][subject][subjects][perf]"){ } - SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ -- GitLab From 6830d6fa1df0a502e30264b6d4b94089cfc4d849 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 4 Apr 2014 16:52:50 -0700 Subject: [PATCH 249/782] add publish, ref_count and connectable_observable --- Rx/v2/src/rxcpp/operators/rx-publish.hpp | 78 +++++++++++++++++++ Rx/v2/src/rxcpp/operators/rx-ref_count.hpp | 70 +++++++++++++++++ Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 64 +++++++++++++++ Rx/v2/src/rxcpp/rx-includes.hpp | 1 + Rx/v2/src/rxcpp/rx-observable.hpp | 11 +++ Rx/v2/src/rxcpp/rx-operators.hpp | 2 + Rx/v2/src/rxcpp/rx-predef.hpp | 5 ++ Rx/v2/src/rxcpp/rx-util.hpp | 10 +-- Rx/v2/test/operators/publish.cpp | 28 +++++++ projects/CMake/CMakeLists.txt | 1 + 10 files changed, 265 insertions(+), 5 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-publish.hpp create mode 100644 Rx/v2/src/rxcpp/operators/rx-ref_count.hpp create mode 100644 Rx/v2/src/rxcpp/rx-connectable_observable.hpp create mode 100644 Rx/v2/test/operators/publish.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-publish.hpp b/Rx/v2/src/rxcpp/operators/rx-publish.hpp new file mode 100644 index 0000000..fcb89f3 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-publish.hpp @@ -0,0 +1,78 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_PUBLISH_HPP) +#define RXCPP_OPERATORS_RX_PUBLISH_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct publish : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type subject_type; + source_type source; + subject_type subject_value; + rxu::detail::maybe connection; + + explicit publish(source_type o) + : source(std::move(o)) + { + } + template + void on_subscribe(Subscriber&& o) { + subject_value.get_observable().subscribe(std::forward(o)); + } + void on_connect(composite_subscription cs) { + if (connection.empty()) { + // the lifetime of each connect is independent + auto destination = subject_value.get_subscriber(); + + // when the paramter is unsubscribed it should + // unsubscribe the most recent connection + connection.reset(cs.add(destination.get_subscription())); + + // when the connection is finished it should shutdown the connection + destination.add(make_subscription( + [cs, this](){ + cs.remove(this->connection.get()); + this->connection.reset(); + })); + + source.subscribe(destination); + } + } +}; + +template class Subject> +class publish_factory +{ +public: + publish_factory() {} + template + auto operator()(Observable&& source) + -> connectable_observable::type::value_type, publish::type::value_type, Observable, Subject::type::value_type>>> { + return connectable_observable::type::value_type, publish::type::value_type, Observable, Subject::type::value_type>>>( + publish::type::value_type, Observable, Subject::type::value_type>>(std::forward(source))); + } +}; + +} + +inline auto publish() + -> detail::publish_factory { + return detail::publish_factory(); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp new file mode 100644 index 0000000..8d8b1a7 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -0,0 +1,70 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_REF_COUNT_HPP) +#define RXCPP_OPERATORS_RX_REF_COUNT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct ref_count : public operator_base +{ + typedef typename std::decay::type source_type; + + source_type source; + long subscribers; + composite_subscription connection; + + explicit ref_count(source_type o) + : source(std::move(o)) + , subscribers(0) + { + } + + template + void on_subscribe(Subscriber&& o) { + auto needConnect = ++subscribers == 1; + o.add(make_subscription( + [this](){ + if (--this->subscribers == 0) { + this->connection.unsubscribe(); + } + })); + source.subscribe(std::forward(o)); + if (needConnect) { + connection = source.connect(); + } + } +}; + +class ref_count_factory +{ +public: + ref_count_factory() {} + template + auto operator()(Observable&& source) + -> observable::type::value_type, ref_count::type::value_type, Observable>> { + return observable::type::value_type, ref_count::type::value_type, Observable>>( + ref_count::type::value_type, Observable>(std::forward(source))); + } +}; + +} + +inline auto ref_count() + -> detail::ref_count_factory { + return detail::ref_count_factory(); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp new file mode 100644 index 0000000..590c5dd --- /dev/null +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -0,0 +1,64 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_CONNECTABLE_OBSERVABLE_HPP) +#define RXCPP_RX_CONNECTABLE_OBSERVABLE_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +template +class connectable_observable + : public observable +{ +public: + typedef connectable_observable this_type; + typedef tag_connectable_observable observable_tag; + typedef observable base_type; + + connectable_observable() + { + } + + explicit connectable_observable(const SourceOperator& o) + : base_type(o) + { + } + explicit connectable_observable(SourceOperator&& o) + : base_type(std::move(o)) + { + } + + // implicit conversion between observables of the same value_type + template + connectable_observable(const connectable_observable& o) + : base_type(o) + {} + // implicit conversion between observables of the same value_type + template + connectable_observable(connectable_observable&& o) + : base_type(std::move(o)) + {} + + composite_subscription connect(composite_subscription cs = composite_subscription()) { + base_type::source_operator.on_connect(cs); + return cs; + } + + /// -> + /// + /// + auto ref_count() const + -> observable> { + return observable>( + rxo::detail::ref_count(*this)); + } + +}; + + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index ba13539..b15a3d1 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -107,6 +107,7 @@ #include "rx-subjects.hpp" #include "rx-operators.hpp" #include "rx-observable.hpp" +#include "rx-connectable_observable.hpp" #pragma pop_macro("min") #pragma pop_macro("max") diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 8282ea2..10cf825 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -270,6 +270,17 @@ public: rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); } + /// publish -> + /// turns a cold observable hot and allows connections to the source to be independent of subscriptions + /// +#if 1 + auto publish() const + -> connectable_observable>> { + return connectable_observable>>( + rxo::detail::publish>(*this)); + } +#endif + /// /// takes any function that will take this observable and produce a result value. /// this is intended to allow externally defined operators to be connected into the expression. diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index a6071c9..e23a936 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -38,5 +38,7 @@ namespace rxo=operators; #include "operators/rx-filter.hpp" #include "operators/rx-map.hpp" #include "operators/rx-flat_map.hpp" +#include "operators/rx-publish.hpp" +#include "operators/rx-ref_count.hpp" #endif diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 1926c17..7e6f987 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -135,6 +135,11 @@ public: static const bool value = std::is_convertible::type>(0)), tag_observable>::value; }; +struct tag_connectable_observable {}; + +template +class connectable_observable; + } #endif diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 6e7db79..eb25e67 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -62,7 +62,7 @@ public: : is_set(false) { if (other.is_set) { - new (reinterpret_cast(&storage)) T(*other.get()); + new (reinterpret_cast(&storage)) T(other.get()); is_set = true; } } @@ -70,7 +70,7 @@ public: : is_set(false) { if (other.is_set) { - new (reinterpret_cast(&storage)) T(std::move(*other.get())); + new (reinterpret_cast(&storage)) T(std::move(other.get())); is_set = true; other.reset(); } @@ -125,13 +125,13 @@ public: return *reinterpret_cast(&storage); } - T& value() { + T& get() { if (!is_set) abort(); return *reinterpret_cast(&storage); } - const T& value() const { + const T& get() const { if (!is_set) abort(); - return *reinterpret_cast(&storage); + return *reinterpret_cast(&storage); } void reset() diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp new file mode 100644 index 0000000..56fa2f2 --- /dev/null +++ b/Rx/v2/test/operators/publish.cpp @@ -0,0 +1,28 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + + +SCENARIO("publish range", "[range][subject][publish][operators]"){ + GIVEN("a range"){ + WHEN("published"){ + auto published = rxs::range(0, 1000).publish().ref_count(); + std::cout << "connect to published" << std::endl; + published.subscribe( + // on_next + [](int v){std::cout << v << ", ";}, + // on_completed + [](){std::cout << std::endl;}); + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 11447e4..27b69b3 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -43,6 +43,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp + ${V2_TEST_DIR}/operators/publish.cpp ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/subscription.cpp ${V2_TEST_DIR}/operators/flat_map.cpp -- GitLab From 0f12d12602aef386e1c3cdbea4f899144fc50129 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 4 Apr 2014 18:20:35 -0700 Subject: [PATCH 250/782] added connect_now --- Rx/v2/src/rxcpp/operators/rx-connect_now.hpp | 58 +++++++++++++++++++ Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 18 +++++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/publish.cpp | 4 +- 4 files changed, 77 insertions(+), 4 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-connect_now.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-connect_now.hpp b/Rx/v2/src/rxcpp/operators/rx-connect_now.hpp new file mode 100644 index 0000000..ff998f0 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-connect_now.hpp @@ -0,0 +1,58 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_CONNECT_NOW_HPP) +#define RXCPP_OPERATORS_RX_CONNECT_NOW_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct connect_now : public operator_base +{ + typedef typename std::decay::type source_type; + + source_type source; + + explicit connect_now(source_type o) + : source(std::move(o)) + { + source.connect(); + } + + template + void on_subscribe(Subscriber&& o) { + source.subscribe(std::forward(o)); + } +}; + +class connect_now_factory +{ +public: + connect_now_factory() {} + template + auto operator()(Observable&& source) + -> observable::type::value_type, connect_now::type::value_type, Observable>> { + return observable::type::value_type, connect_now::type::value_type, Observable>>( + connect_now::type::value_type, Observable>(std::forward(source))); + } +}; + +} + +inline auto connect_now() + -> detail::connect_now_factory { + return detail::connect_now_factory(); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index 590c5dd..39590dd 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -47,8 +47,11 @@ public: return cs; } - /// -> - /// + /// ref_count -> + /// takes a connectable_observable source and uses a ref_count of the subscribers + /// to control the connection to the published source. The first subscription + /// will cause a call to connect() and the last unsubscribe will unsubscribe the + /// connection. /// auto ref_count() const -> observable> { @@ -56,6 +59,17 @@ public: rxo::detail::ref_count(*this)); } + /// connect_now -> + /// takes a connectable_observable source and calls connect during + /// the construction of the expression. This means that the source + /// starts running without any subscribers and continues running + /// after all subscriptions have been unsubscribed. + /// + auto connect_now() const + -> observable> { + return observable>( + rxo::detail::connect_now(*this)); + } }; diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index e23a936..3ada268 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -40,5 +40,6 @@ namespace rxo=operators; #include "operators/rx-flat_map.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" +#include "operators/rx-connect_now.hpp" #endif diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 56fa2f2..5a0fd2b 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -16,13 +16,13 @@ namespace rxt=rxcpp::test; SCENARIO("publish range", "[range][subject][publish][operators]"){ GIVEN("a range"){ WHEN("published"){ - auto published = rxs::range(0, 1000).publish().ref_count(); + auto published = rxs::range(0, 1000).publish().connect_now(); std::cout << "connect to published" << std::endl; published.subscribe( // on_next [](int v){std::cout << v << ", ";}, // on_completed - [](){std::cout << std::endl;}); + [](){std::cout << " done." << std::endl;}); } } } -- GitLab From 0a583f0cb92926aa916302f66c8e5a13f7e43ccd Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 4 Apr 2014 19:48:45 -0700 Subject: [PATCH 251/782] add dynamic_connectable_observable --- Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 129 +++++++++++++++- Rx/v2/src/rxcpp/rx-observable.hpp | 2 - Rx/v2/src/rxcpp/rx-predef.hpp | 33 +++- Rx/v2/test/operators/publish.cpp | 145 +++++++++++++++++- 4 files changed, 302 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index 39590dd..bf63dd0 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -9,14 +9,132 @@ namespace rxcpp { +namespace detail { + +template +struct has_on_connect +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CT*)nullptr).on_connect(composite_subscription())); + template + static not_void check(...); + + typedef decltype(check(0)) detail_result; + static const bool value = std::is_same::value; +}; + +} + +template +class dynamic_connectable_observable + : public rxs::source_base +{ + struct state_type + : public std::enable_shared_from_this + { + typedef std::function)> onsubscribe_type; + typedef std::function onconnect_type; + + onsubscribe_type on_subscribe; + onconnect_type on_connect; + }; + std::shared_ptr state; + + template + void construct(const dynamic_observable& o, tag_dynamic_observable&&) { + state = o.state; + } + + template + void construct(dynamic_observable&& o, tag_dynamic_observable&&) { + state = std::move(o.state); + } + + template + void construct(SO&& source, rxs::tag_source&&) { + auto so = std::make_shared::type>(std::forward(source)); + state->on_subscribe = [so](subscriber o) mutable { + so->on_subscribe(std::move(o)); + }; + state->on_connect = [so](composite_subscription cs) mutable { + so->on_connect(std::move(cs)); + }; + } + +public: + + typedef tag_dynamic_observable dynamic_observable_tag; + + dynamic_connectable_observable() + { + } + + template + explicit dynamic_connectable_observable(SOF&& sof) + : state(std::make_shared()) + { + construct(std::forward(sof), + typename std::conditional::value, tag_dynamic_observable, rxs::tag_source>::type()); + } + + template + dynamic_connectable_observable(SF&& sf, CF&& cf) + : state(std::make_shared()) + { + state->on_subscribe = std::forward(sf); + state->on_connect = std::forward(cf); + } + + void on_subscribe(subscriber o) const { + state->on_subscribe(std::move(o)); + } + + template + typename std::enable_if::type, observer>::value, void>::type + on_subscribe(Subscriber&& o) const { + auto so = std::make_shared::type>(std::forward(o)); + state->on_subscribe(make_subscriber( + *so, + make_observer_dynamic( + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + }))); + } + + void on_connect(composite_subscription cs) const { + state->on_connect(std::move(cs)); + } +}; + +template +connectable_observable make_dynamic_connectable_observable(Source&& s) { + return connectable_observable(dynamic_connectable_observable(std::forward(s))); +} + + + template class connectable_observable : public observable { -public: typedef connectable_observable this_type; - typedef tag_connectable_observable observable_tag; typedef observable base_type; + typedef typename std::decay::type source_operator_type; + + static_assert(detail::has_on_connect::value, "inner must have on_connect method void(composite_subscription)"); + +public: + typedef tag_connectable_observable observable_tag; connectable_observable() { @@ -42,6 +160,13 @@ public: : base_type(std::move(o)) {} + /// + /// performs type-forgetting conversion to a new composite_observable + /// + connectable_observable as_dynamic() { + return *this; + } + composite_subscription connect(composite_subscription cs = composite_subscription()) { base_type::source_operator.on_connect(cs); return cs; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 10cf825..dd471f7 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -273,13 +273,11 @@ public: /// publish -> /// turns a cold observable hot and allows connections to the source to be independent of subscriptions /// -#if 1 auto publish() const -> connectable_observable>> { return connectable_observable>>( rxo::detail::publish>(*this)); } -#endif /// /// takes any function that will take this observable and produce a result value. diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 7e6f987..41cb223 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -135,11 +135,40 @@ public: static const bool value = std::is_convertible::type>(0)), tag_observable>::value; }; -struct tag_connectable_observable {}; +struct tag_dynamic_connectable_observable : public tag_dynamic_observable {}; -template +template +class is_dynamic_connectable_observable +{ + struct not_void {}; + template + static typename C::dynamic_observable_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_dynamic_connectable_observable*>::value; +}; + +template +class dynamic_connectable_observable; + +template::value, + void, dynamic_connectable_observable>::type> class connectable_observable; +struct tag_connectable_observable : public tag_observable {}; +template +class is_connectable_observable +{ + template + static typename C::observable_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_connectable_observable>::value; +}; + } #endif diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 5a0fd2b..9739646 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -16,8 +16,28 @@ namespace rxt=rxcpp::test; SCENARIO("publish range", "[range][subject][publish][operators]"){ GIVEN("a range"){ WHEN("published"){ - auto published = rxs::range(0, 1000).publish().connect_now(); + auto published = rxs::range(0, 10).publish(); + std::cout << "subscribe to published" << std::endl; + published.subscribe( + // on_next + [](int v){std::cout << v << ", ";}, + // on_completed + [](){std::cout << " done." << std::endl;}); std::cout << "connect to published" << std::endl; + published.connect(); + } + WHEN("ref_count is used"){ + auto published = rxs::range(0, 10).publish().ref_count(); + std::cout << "subscribe to ref_count" << std::endl; + published.subscribe( + // on_next + [](int v){std::cout << v << ", ";}, + // on_completed + [](){std::cout << " done." << std::endl;}); + } + WHEN("connect_now is used"){ + auto published = rxs::range(0, 10).publish().connect_now(); + std::cout << "subscribe to connect_now" << std::endl; published.subscribe( // on_next [](int v){std::cout << v << ", ";}, @@ -26,3 +46,126 @@ SCENARIO("publish range", "[range][subject][publish][operators]"){ } } } + +SCENARIO("publish", "[publish][multicast][operators]"){ + GIVEN("a test hot observable of longs"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + long invoked = 0; + + record messages[] = { + on_next(110, 7), + on_next(220, 3), + on_next(280, 4), + on_next(290, 1), + on_next(340, 8), + on_next(360, 5), + on_next(370, 6), + on_next(390, 7), + on_next(410, 13), + on_next(430, 2), + on_next(450, 9), + on_next(520, 11), + on_next(560, 20), + on_completed(600) + }; + auto xs = sc.make_hot_observable(messages); + + auto res = sc.make_subscriber(); + + rx::connectable_observable ys; + + WHEN("subscribed and then connected"){ + + sc.schedule_absolute(rxsc::test::created_time, + [&invoked, &ys, &xs](const rxsc::schedulable& scbl){ + ys = xs.publish().as_dynamic(); + //ys = xs.publish_last().as_dynamic(); + }); + + sc.schedule_absolute(rxsc::test::subscribed_time, + [&ys, &res](const rxsc::schedulable& scbl){ + ys.subscribe(res); + }); + + sc.schedule_absolute(rxsc::test::unsubscribed_time, + [&res](const rxsc::schedulable& scbl){ + res.unsubscribe(); + }); + + { + rx::composite_subscription connection; + + sc.schedule_absolute(300, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + sc.schedule_absolute(400, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + { + rx::composite_subscription connection; + + sc.schedule_absolute(500, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + sc.schedule_absolute(550, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + { + rx::composite_subscription connection; + + sc.schedule_absolute(650, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + sc.schedule_absolute(800, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + sc.start(); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(340, 8), + on_next(360, 5), + on_next(370, 6), + on_next(390, 7), + on_next(520, 11) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there were 3 subscription/unsubscription"){ + life items[] = { + subscribe(300, 400), + subscribe(500, 550), + subscribe(650, 800) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + -- GitLab From 24e0c50468c66846e4b3aab51931ba301261e27d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 4 Apr 2014 22:12:26 -0700 Subject: [PATCH 252/782] added take_until --- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 170 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 10 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/publish.cpp | 2 +- Rx/v2/test/operators/take.cpp | 86 ++++++++++ projects/CMake/CMakeLists.txt | 1 + 7 files changed, 270 insertions(+), 2 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-take_until.hpp create mode 100644 Rx/v2/test/operators/take.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index 28f2caa..b54deab 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -32,7 +32,7 @@ struct filter : public operator_base static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); } template - void on_subscribe(Subscriber o) { + void on_subscribe(const Subscriber& o) { source.subscribe( o, // on_next diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp new file mode 100644 index 0000000..4c6a0ee --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -0,0 +1,170 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_TAKE_HPP) +#define RXCPP_OPERATORS_RX_TAKE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct take_until : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type trigger_source_type; + struct values + { + values(source_type s, trigger_source_type t) + : source(std::move(s)) + , trigger(std::move(t)) + { + } + source_type source; + trigger_source_type trigger; + }; + values initial; + + take_until(source_type s, trigger_source_type t) + : initial(std::move(s), std::move(t)) + { + } + + struct mode + { + enum type { + taking, + clear, + triggered, + errored, + stopped + }; + }; + + template + void on_subscribe(const Subscriber& s) { + + typedef Subscriber output_type; + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(const values& i, const output_type& oarg) + : values(i) + , mode_value(mode::taking) + , busy(0) + , out(oarg) + { + } + mutable std::atomic mode_value; + mutable std::atomic busy; + mutable std::exception_ptr exception; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, s)); + + struct activity + { + const std::shared_ptr& st; + ~activity() { + if (--st->busy == 0 && st->mode_value > mode::clear) { + // need to finish + if (st->mode_value < mode::stopped && ++st->busy == 1) { + // this is the finish owner + auto fin = st->mode_value.exchange(mode::stopped); + if (fin == mode::triggered) { + st->out.on_completed(); + } else if (fin == mode::errored) { + st->out.on_error(st->exception); + } + } + } + } + explicit activity(const std::shared_ptr& st) + : st(st) + { + ++st->busy; + } + + }; + + state->trigger.subscribe( + // share subscription lifetime + state->out, + // on_next + [state](const typename trigger_source_type::value_type&) { + activity finisher(state); + state->mode_value = mode::triggered; + }, + // on_error + [state](std::exception_ptr e) { + activity finisher(state); + state->exception = e; + state->mode_value = mode::errored; + }, + // on_completed + [state]() { + activity finisher(state); + state->mode_value = mode::clear; + } + ); + + state->source.subscribe( + // share subscription lifetime + state->out, + // on_next + [state](T t) { + activity finisher(state); + if (state->mode_value < mode::triggered) { + state->out.on_next(t); + } + }, + // on_error + [state](std::exception_ptr e) { + activity finisher(state); + state->exception = e; + state->mode_value = mode::errored; + }, + // on_completed + [state]() { + activity finisher(state); + state->mode_value = mode::triggered; + } + ); + } +}; + +template +class take_until_factory +{ + typedef typename std::decay::type trigger_source_type; + trigger_source_type trigger_source; +public: + take_until_factory(trigger_source_type t) : trigger_source(std::move(t)) {} + template + auto operator()(Observable&& source) + -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type>> { + return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type>>( + take_until::type::value_type, Observable, trigger_source_type>(std::forward(source), std::move(trigger_source))); + } +}; + +} + +template +auto take_until(TriggerObservable&& t) + -> detail::take_until_factory { + return detail::take_until_factory(std::forward(t)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index dd471f7..79a2239 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -279,6 +279,16 @@ public: rxo::detail::publish>(*this)); } + /// take_until -> + /// + /// + template + auto take_until(TriggerSource&& t) const + -> observable> { + return observable>( + rxo::detail::take_until(*this, std::forward(t))); + } + /// /// takes any function that will take this observable and produce a result value. /// this is intended to allow externally defined operators to be connected into the expression. diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 3ada268..18a974c 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -41,5 +41,6 @@ namespace rxo=operators; #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" #include "operators/rx-connect_now.hpp" +#include "operators/rx-take_until.hpp" #endif diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 9739646..8d044f0 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -13,7 +13,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -SCENARIO("publish range", "[range][subject][publish][operators]"){ +SCENARIO("publish range", "[hide][range][subject][publish][operators]"){ GIVEN("a range"){ WHEN("published"){ auto published = rxs::range(0, 10).publish(); diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp new file mode 100644 index 0000000..eb4cd50 --- /dev/null +++ b/Rx/v2/test/operators/take.cpp @@ -0,0 +1,86 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + + +SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto xs = sc.make_hot_observable(xmessages); + + record ymessages[] = { + on_next(150, 1), + on_next(225, 99), + on_completed(230) + }; + auto ys = sc.make_hot_observable(ymessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [xs, ys]() { + return xs + .take_until(ys) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_completed(225) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 27b69b3..0c75e10 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -43,6 +43,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp + ${V2_TEST_DIR}/operators/take.cpp ${V2_TEST_DIR}/operators/publish.cpp ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/subscription.cpp -- GitLab From d230f4cb858482012d27ff66399c63f868163b64 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 28 Apr 2014 10:55:53 -0700 Subject: [PATCH 253/782] add take operator --- Rx/v2/src/rxcpp/operators/rx-take.hpp | 125 ++++++++++++++++++++ Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 6 +- Rx/v2/src/rxcpp/rx-observable.hpp | 10 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + 4 files changed, 139 insertions(+), 3 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-take.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp new file mode 100644 index 0000000..b8ddc2f --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -0,0 +1,125 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_TAKE_HPP) +#define RXCPP_OPERATORS_RX_TAKE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct take : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type count_type; + struct values + { + values(source_type s, count_type t) + : source(std::move(s)) + , count(std::move(t)) + { + } + source_type source; + count_type count; + }; + values initial; + + take(source_type s, count_type t) + : initial(std::move(s), std::move(t)) + { + } + + struct mode + { + enum type { + taking, + clear, + triggered, + errored, + stopped + }; + }; + + template + void on_subscribe(const Subscriber& s) { + + typedef Subscriber output_type; + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(const values& i, const output_type& oarg) + : values(i) + , mode_value(mode::taking) + , out(oarg) + { + } + typename mode::type mode_value; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, s)); + + state->source.subscribe( + // share subscription lifetime + state->out, + // on_next + [state](T t) { + if (state->mode_value < mode::triggered) { + if (--state->count > 0) { + state->out.on_next(t); + } else { + state->out.on_next(t); + state->mode_value = mode::clear; + state->out.unsubscribe(); + } + } + }, + // on_error + [state](std::exception_ptr e) { + state->mode_value = mode::errored; + state->out.on_error(e); + }, + // on_completed + [state]() { + state->mode_value = mode::triggered; + state->out.on_completed(); + } + ); + } +}; + +template +class take_factory +{ + typedef typename std::decay::type count_type; + count_type count; +public: + take_factory(count_type t) : count(std::move(t)) {} + template + auto operator()(Observable&& source) + -> observable::type::value_type, take::type::value_type, Observable, count_type>> { + return observable::type::value_type, take::type::value_type, Observable, count_type>>( + take::type::value_type, Observable, count_type>(std::forward(source), count)); + } +}; + +} + +template +auto take(T&& t) + -> detail::take_factory { + return detail::take_factory(std::forward(t)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 4c6a0ee..608cde4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -2,8 +2,8 @@ #pragma once -#if !defined(RXCPP_OPERATORS_RX_TAKE_HPP) -#define RXCPP_OPERATORS_RX_TAKE_HPP +#if !defined(RXCPP_OPERATORS_RX_TAKE_UNTIL_HPP) +#define RXCPP_OPERATORS_RX_TAKE_UNTIL_HPP #include "../rx-includes.hpp" @@ -151,7 +151,7 @@ public: auto operator()(Observable&& source) -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type>> { return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type>>( - take_until::type::value_type, Observable, trigger_source_type>(std::forward(source), std::move(trigger_source))); + take_until::type::value_type, Observable, trigger_source_type>(std::forward(source), trigger_source)); } }; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 79a2239..2573353 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -279,6 +279,16 @@ public: rxo::detail::publish>(*this)); } + /// take -> + /// + /// + template + auto take(Count&& t) const + -> observable> { + return observable>( + rxo::detail::take(*this, std::forward(t))); + } + /// take_until -> /// /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 18a974c..b0fa902 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -41,6 +41,7 @@ namespace rxo=operators; #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" #include "operators/rx-connect_now.hpp" +#include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" #endif -- GitLab From cca6c778873f8de810a4bd11bd263df214237538 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 28 Apr 2014 10:56:15 -0700 Subject: [PATCH 254/782] remove some default constructors --- Rx/v2/src/rxcpp/rx-observer.hpp | 7 +++---- Rx/v2/src/rxcpp/rx-subscriber.hpp | 4 +--- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 74946e8..23b58ab 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -202,14 +202,13 @@ class observer : public observer_base typedef typename std::decay::type inner_t; inner_t inner; + + observer(); public: ~observer() { } - observer() - { - } - observer(inner_t inner) + explicit observer(inner_t inner) : inner(std::move(inner)) { } diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index fbf04be..92b672f 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -40,13 +40,11 @@ class subscriber : public subscriber_base const this_type* that; }; + subscriber(); public: typedef typename composite_subscription::weak_subscription weak_subscription; typedef typename composite_subscription::shared_subscription shared_subscription; - subscriber() - { - } template subscriber(composite_subscription cs, resumption r, U&& o) : lifetime(std::move(cs)) -- GitLab From 9d8db1823e90aaa62bd33b2ff93d3b5c5e0c2891 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 28 Apr 2014 10:57:02 -0700 Subject: [PATCH 255/782] check subscription before calling action --- Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 2384581..4eddf52 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -225,7 +225,9 @@ public: queue::pop(); - what(recursor); + if (what.is_subscribed()) { + what(recursor); + } if (queue::empty()) { break; -- GitLab From 46017d9e4d61e89dd1f3fb44cb662b8d65697058 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 28 Apr 2014 16:16:32 -0700 Subject: [PATCH 256/782] fixes and test for take --- Rx/v2/src/rxcpp/operators/rx-take.hpp | 7 ++- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 30 ++++++++--- Rx/v2/test/operators/take.cpp | 56 +++++++++++++++++++++ 3 files changed, 82 insertions(+), 11 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index b8ddc2f..ff903f0 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -39,7 +39,6 @@ struct take : public operator_base { enum type { taking, - clear, triggered, errored, stopped @@ -75,9 +74,9 @@ struct take : public operator_base if (--state->count > 0) { state->out.on_next(t); } else { + state->mode_value = mode::triggered; state->out.on_next(t); - state->mode_value = mode::clear; - state->out.unsubscribe(); + state->out.on_completed(); } } }, @@ -88,7 +87,7 @@ struct take : public operator_base }, // on_completed [state]() { - state->mode_value = mode::triggered; + state->mode_value = mode::stopped; state->out.on_completed(); } ); diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 608cde4..c93d568 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -63,6 +63,7 @@ struct take_until : public operator_base } mutable std::atomic mode_value; mutable std::atomic busy; + mutable std::mutex error_lock; mutable std::exception_ptr exception; output_type out; }; @@ -81,6 +82,7 @@ struct take_until : public operator_base if (fin == mode::triggered) { st->out.on_completed(); } else if (fin == mode::errored) { + std::unique_lock guard(st->error_lock); st->out.on_error(st->exception); } } @@ -100,18 +102,26 @@ struct take_until : public operator_base // on_next [state](const typename trigger_source_type::value_type&) { activity finisher(state); - state->mode_value = mode::triggered; + typename mode::type v = state->mode_value; + if (v != mode::taking) {return;} + state->mode_value.compare_exchange_strong(v, mode::triggered); }, // on_error [state](std::exception_ptr e) { activity finisher(state); - state->exception = e; - state->mode_value = mode::errored; + std::unique_lock guard(state->error_lock); + typename mode::type v = state->mode_value; + if (v != mode::taking) {return;} + if (state->mode_value.compare_exchange_strong(v, mode::errored)) { + state->exception = e; + } }, // on_completed [state]() { activity finisher(state); - state->mode_value = mode::clear; + typename mode::type v = state->mode_value; + if (v != mode::taking) {return;} + state->mode_value.compare_exchange_strong(v, mode::clear); } ); @@ -128,13 +138,19 @@ struct take_until : public operator_base // on_error [state](std::exception_ptr e) { activity finisher(state); - state->exception = e; - state->mode_value = mode::errored; + std::unique_lock guard(state->error_lock); + typename mode::type v = state->mode_value; + if (v < mode::triggered) {return;} + if (state->mode_value.compare_exchange_strong(v, mode::errored)) { + state->exception = e; + } }, // on_completed [state]() { activity finisher(state); - state->mode_value = mode::triggered; + typename mode::type v = state->mode_value; + if (v < mode::triggered) {return;} + state->mode_value.compare_exchange_strong(v, mode::triggered); } ); } diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index eb4cd50..fb318e6 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -12,6 +12,62 @@ namespace rxt=rxcpp::test; #include "catch.hpp" +SCENARIO("take 2", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("2 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_completed(220) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 220) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ GIVEN("2 sources"){ -- GitLab From 203c098fbca73b6a52da08b34ff2f5d9835fc1d6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 28 Apr 2014 21:07:38 -0700 Subject: [PATCH 257/782] add some pythagorian perf tests --- Rx/v2/test/operators/flat_map.cpp | 78 +++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 1fff6a4..faf194e 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,6 +12,84 @@ namespace rxt=rxcpp::test; #include "catch.hpp" +static const int static_tripletCount = 500; + +SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("a for loop"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + int ct = 0; + int n = 1; + auto start = clock::now(); + for(int z = 1;; ++z) + { + for(int x = 1; x <= z; ++x) + { + for(int y = x; y <= z; ++y) + { + ++c; + if(x*x + y*y == z*z) + { + //result += (x + y + z); + //std::cout << x << "," << y << "," << z << std::endl; + ++ct; + if(ct == tripletCount) + goto done; + } + } + } + } + done: + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} + +SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + int ct = 0; + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1) + .flat_map( + [&c](int z){ return rxs::range(1, z) + .flat_map( + [&c, z](int x){ return rxs::range(x, z) + .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) + .map([z, x](int y){return std::make_tuple(x, y, z);});}, + [](int x, std::tuple triplet){return triplet;});}, + [](int z, std::tuple triplet){return triplet;}); + triples + .take(tripletCount) + .subscribe( + [&ct](std::tuple triplet){++ct; + //int x,y,z; std::tie(x,y,z) = triplet; std::cout << x << "," << y << "," << z << std::endl; + }, + [](std::exception_ptr){abort();}); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} + SCENARIO("flat_map completes", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); -- GitLab From 44fa1e294dbac1d5774f7a11d6a8a53a9ea230df Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Apr 2014 08:46:49 -0700 Subject: [PATCH 258/782] separate lifetime of trigger subscription --- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index c93d568..6b97cb8 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -96,9 +96,14 @@ struct take_until : public operator_base }; + composite_subscription trigger_lifetime; + state->out.add(trigger_lifetime); + state->trigger.subscribe( - // share subscription lifetime + // share parts of subscription state->out, + // new lifetime + trigger_lifetime, // on_next [state](const typename trigger_source_type::value_type&) { activity finisher(state); @@ -130,6 +135,9 @@ struct take_until : public operator_base state->out, // on_next [state](T t) { + // + // everything is crafted to minimize the overhead of this function. + // activity finisher(state); if (state->mode_value < mode::triggered) { state->out.on_next(t); -- GitLab From 0365049a3cb955789188e38ccc02d7b3bcc22acc Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Apr 2014 08:47:07 -0700 Subject: [PATCH 259/782] port many more tests for take and take_until --- Rx/v2/test/operators/take.cpp | 1465 ++++++++++++++++++++++++++++++++- 1 file changed, 1445 insertions(+), 20 deletions(-) diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index fb318e6..7926668 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -68,8 +68,1133 @@ SCENARIO("take 2", "[take][operators]"){ } } +SCENARIO("take, complete after", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_completed(690) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("20 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(20) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_completed(690) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 690) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, complete same", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_completed(690) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("17 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(17) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_completed(630) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 630) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, complete before", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_completed(690) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("10 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(10) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_completed(415) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 415) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, error after", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + std::runtime_error ex("take on_error from source"); + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_error(690, ex) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("20 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(20) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_error(690, ex) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 690) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, error same", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_error(690, std::runtime_error("error in unsubscribed stream")) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("17 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(17) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_completed(630) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 630) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, error before", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10), + on_error(690, std::runtime_error("error in unsubscribed stream")) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("3 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_completed(270) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 270) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, dispose before", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("3 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 250 + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take, dispose after", "[take][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(70, 6), + on_next(150, 4), + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_next(280, 1), + on_next(300, -1), + on_next(310, 3), + on_next(340, 8), + on_next(370, 11), + on_next(410, 15), + on_next(415, 16), + on_next(460, 72), + on_next(510, 76), + on_next(560, 32), + on_next(570, -100), + on_next(580, -3), + on_next(590, 5), + on_next(630, 10) + }; + auto xs = sc.make_hot_observable(xmessages); + + WHEN("3 values are taken"){ + + auto res = sc.start( + [xs]() { + return xs + .take(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 400 + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 9), + on_next(230, 13), + on_next(270, 7), + on_completed(270) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 270) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + + + +SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record xmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto xs = sc.make_hot_observable(xmessages); + + record ymessages[] = { + on_next(150, 1), + on_next(225, 99), + on_completed(230) + }; + auto ys = sc.make_hot_observable(ymessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [xs, ys]() { + return xs + .take_until(ys) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_completed(225) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record lmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_next(225, 99), + on_completed(230) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_completed(225) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt some data error", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + std::runtime_error ex("take_until on_error from source"); + + record lmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_error(225, ex) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_error(225, ex) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record lmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_completed(225) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record lmessages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record lmessages[] = { + on_next(150, 1) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_next(225, 2), //! + on_completed(250) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_completed(225) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + std::runtime_error ex("take_until on_error from source"); + + record lmessages[] = { + on_next(150, 1) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_error(225, ex) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_error(225, ex) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } -SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); typedef rxsc::test::messages m; @@ -80,29 +1205,147 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ auto on_completed = m::on_completed; auto subscribe = m::subscribe; - record xmessages[] = { + record lmessages[] = { + on_next(150, 1) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) + on_completed(225) }; - auto xs = sc.make_hot_observable(xmessages); + auto r = sc.make_hot_observable(rmessages); - record ymessages[] = { + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = std::vector(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 225) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record lmessages[] = { + on_next(150, 1) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = std::vector(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 1000) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 1000) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt before first produced", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record lmessages[] = { on_next(150, 1), - on_next(225, 99), - on_completed(230) + on_next(230, 2), + on_completed(240) }; - auto ys = sc.make_hot_observable(ymessages); + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_next(210, 2), //! + on_completed(220) + }; + auto r = sc.make_hot_observable(rmessages); WHEN("one is taken until the other emits a marble"){ auto res = sc.start( - [xs, ys]() { - return xs - .take_until(ys) + [l, r]() { + return l + .take_until(r) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); } @@ -110,9 +1353,191 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ THEN("the output only contains items sent while subscribed"){ record items[] = { - on_next(210, 2), - on_next(220, 3), - on_completed(225) + on_completed(210) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + life items[] = { + subscribe(200, 210) + }; + auto required = rxu::to_vector(items); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + life items[] = { + subscribe(200, 210) + }; + auto required = rxu::to_vector(items); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt before first produced, remain silent and proper unsubscribed", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + bool sourceNotDisposed = false; + + record lmessages[] = { + on_next(150, 1), + on_error(215, std::runtime_error("error in unsubscribed stream")), // should not come + on_completed(240) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_next(210, 2), //! + on_completed(220) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r, &sourceNotDisposed]() { + return l + .map([&sourceNotDisposed](int v){sourceNotDisposed = true; return v;}) + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_completed(210) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("signal disposed"){ + auto required = false; + auto actual = sourceNotDisposed; + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + bool signalNotDisposed = false; + + record lmessages[] = { + on_next(150, 1), + on_next(230, 2), + on_completed(240) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_next(250, 2), + on_completed(260) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r, &signalNotDisposed]() { + return l + .take_until(r + .map([&signalNotDisposed](int v){signalNotDisposed = true; return v;})) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(230, 2), + on_completed(240) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("signal disposed"){ + auto required = false; + auto actual = signalNotDisposed; + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, error some", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + std::runtime_error ex("take_until on_error from source"); + + record lmessages[] = { + on_next(150, 1), + on_error(225, ex) + }; + auto l = sc.make_hot_observable(lmessages); + + record rmessages[] = { + on_next(150, 1), + on_next(240, 2) + }; + auto r = sc.make_hot_observable(rmessages); + + WHEN("one is taken until the other emits a marble"){ + + auto res = sc.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_error(225, ex) }; auto required = rxu::to_vector(items); auto actual = res.get_observer().messages(); @@ -124,7 +1549,7 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ subscribe(200, 225) }; auto required = rxu::to_vector(items); - auto actual = xs.subscriptions(); + auto actual = l.subscriptions(); REQUIRE(required == actual); } @@ -133,7 +1558,7 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ subscribe(200, 225) }; auto required = rxu::to_vector(items); - auto actual = ys.subscriptions(); + auto actual = r.subscriptions(); REQUIRE(required == actual); } -- GitLab From 4db682b6317b08d58755471f21eb025b4693bc9c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Apr 2014 17:23:15 -0700 Subject: [PATCH 260/782] simplified and fixed a bug in take_until --- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 71 ++++++++++----------- 1 file changed, 34 insertions(+), 37 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 6b97cb8..35c7fe6 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -50,11 +50,11 @@ struct take_until : public operator_base void on_subscribe(const Subscriber& s) { typedef Subscriber output_type; - struct state_type - : public std::enable_shared_from_this + struct take_until_state_type + : public std::enable_shared_from_this , public values { - state_type(const values& i, const output_type& oarg) + take_until_state_type(const values& i, const output_type& oarg) : values(i) , mode_value(mode::taking) , busy(0) @@ -63,32 +63,33 @@ struct take_until : public operator_base } mutable std::atomic mode_value; mutable std::atomic busy; - mutable std::mutex error_lock; + mutable std::mutex finish_lock; mutable std::exception_ptr exception; output_type out; }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, s)); + auto state = std::shared_ptr(new take_until_state_type(initial, s)); struct activity { - const std::shared_ptr& st; + const std::shared_ptr& st; ~activity() { if (--st->busy == 0 && st->mode_value > mode::clear) { // need to finish - if (st->mode_value < mode::stopped && ++st->busy == 1) { - // this is the finish owner - auto fin = st->mode_value.exchange(mode::stopped); - if (fin == mode::triggered) { - st->out.on_completed(); - } else if (fin == mode::errored) { - std::unique_lock guard(st->error_lock); - st->out.on_error(st->exception); - } + // this is the finish owner + std::unique_lock guard(st->finish_lock); + typename mode::type fin = st->mode_value; + auto ex = st->exception; + st->mode_value.exchange(mode::stopped); + guard.unlock(); + if (fin == mode::triggered) { + st->out.on_completed(); + } else if (fin == mode::errored) { + st->out.on_error(ex); } } } - explicit activity(const std::shared_ptr& st) + explicit activity(const std::shared_ptr& st) : st(st) { ++st->busy; @@ -107,26 +108,24 @@ struct take_until : public operator_base // on_next [state](const typename trigger_source_type::value_type&) { activity finisher(state); - typename mode::type v = state->mode_value; - if (v != mode::taking) {return;} - state->mode_value.compare_exchange_strong(v, mode::triggered); + std::unique_lock guard(state->finish_lock); + if (state->mode_value != mode::taking) {return;} + state->mode_value.exchange(mode::triggered); }, // on_error [state](std::exception_ptr e) { activity finisher(state); - std::unique_lock guard(state->error_lock); - typename mode::type v = state->mode_value; - if (v != mode::taking) {return;} - if (state->mode_value.compare_exchange_strong(v, mode::errored)) { - state->exception = e; - } + std::unique_lock guard(state->finish_lock); + if (state->mode_value != mode::taking) {return;} + state->mode_value.exchange(mode::errored); + state->exception = e; }, // on_completed [state]() { activity finisher(state); - typename mode::type v = state->mode_value; - if (v != mode::taking) {return;} - state->mode_value.compare_exchange_strong(v, mode::clear); + std::unique_lock guard(state->finish_lock); + if (state->mode_value != mode::taking) {return;} + state->mode_value.exchange(mode::clear); } ); @@ -146,19 +145,17 @@ struct take_until : public operator_base // on_error [state](std::exception_ptr e) { activity finisher(state); - std::unique_lock guard(state->error_lock); - typename mode::type v = state->mode_value; - if (v < mode::triggered) {return;} - if (state->mode_value.compare_exchange_strong(v, mode::errored)) { - state->exception = e; - } + std::unique_lock guard(state->finish_lock); + if (state->mode_value > mode::clear) {return;} + state->mode_value.exchange(mode::errored); + state->exception = e; }, // on_completed [state]() { activity finisher(state); - typename mode::type v = state->mode_value; - if (v < mode::triggered) {return;} - state->mode_value.compare_exchange_strong(v, mode::triggered); + std::unique_lock guard(state->finish_lock); + if (state->mode_value > mode::clear) {return;} + state->mode_value.exchange(mode::triggered); } ); } -- GitLab From 6d6f9660f923e7d5ce0afe41466cec85c174c0a2 Mon Sep 17 00:00:00 2001 From: Tobias Furuholm Date: Thu, 1 May 2014 21:55:55 +0200 Subject: [PATCH 261/782] action_queue and virtual_time scheduling order fix --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 58 +++++++++++++++++++ .../src/rxcpp/schedulers/rx-currentthread.hpp | 13 +---- Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 14 +---- Rx/v2/test/operators/flat_map.cpp | 10 ++-- 4 files changed, 66 insertions(+), 29 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index b323449..93c6ed9 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -600,6 +600,8 @@ namespace detail { template struct time_schedulable { + typedef TimePoint time_point_type; + time_schedulable(TimePoint when, schedulable a) : when(when) , what(std::move(a)) @@ -609,6 +611,62 @@ struct time_schedulable schedulable what; }; + +// Sorts time_schedulable items in priority order sorted +// on value of time_schedulable.when. Items with equal +// values for when are sorted in fifo order. +template +class schedulable_queue { +public: + typedef time_schedulable item_type; + typedef std::pair elem_type; + typedef std::vector container_type; + typedef const item_type& const_reference; + +private: + struct compare_elem + { + bool operator()(const elem_type& lhs, const elem_type& rhs) const { + if (lhs.first.when == rhs.first.when) { + return lhs.second > rhs.second; + } + else { + return lhs.first.when > rhs.first.when; + } + } + }; + + typedef std::priority_queue< + elem_type, + container_type, + compare_elem + > queue_type; + + queue_type queue; + + std::int64_t ordinal; +public: + const_reference top() const { + return queue.top().first; + } + + void pop() { + queue.pop(); + } + + bool empty() const { + return queue.empty(); + } + + void push(const item_type& value) { + queue.push(elem_type(value, ordinal++)); + } + + void push(item_type&& value) { + queue.push(elem_type(std::move(value), ordinal++)); + } +}; + } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 4eddf52..e819418 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -21,18 +21,7 @@ struct action_queue typedef time_schedulable item_type; private: - struct compare_item_time - { - bool operator()(const item_type& lhs, const item_type& rhs) const { - return lhs.when > rhs.when; - } - }; - - typedef std::priority_queue< - item_type, - std::vector, - compare_item_time - > queue_item_time; + typedef schedulable_queue queue_item_time; public: struct current_thread_queue_type { diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index c162a02..b8fe30f 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -188,18 +188,8 @@ private: typedef typename base::item_type item_type; - struct compare_item_time - { - bool operator()(const item_type& lhs, const item_type& rhs) const { - return lhs.when > rhs.when; - } - }; - - typedef std::priority_queue< - item_type, - std::vector, - compare_item_time - > queue_item_time; + typedef detail::schedulable_queue< + typename item_type::time_point_type> queue_item_time; mutable queue_item_time queue; diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index faf194e..7e6401e 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -154,8 +154,8 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ son_next(600, "bar"), son_next(650, "baz"), son_next(650, "foo"), - son_next(700, "bar"), son_next(700, "qux"), + son_next(700, "bar"), son_next(750, "baz"), son_next(800, "qux"), son_completed(850) @@ -242,20 +242,20 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ son_next(400, "bar"), son_next(450, "baz"), son_next(450, "foo"), - son_next(500, "bar"), son_next(500, "qux"), + son_next(500, "bar"), son_next(550, "baz"), son_next(550, "foo"), - son_next(600, "bar"), son_next(600, "qux"), + son_next(600, "bar"), son_next(650, "baz"), son_next(650, "foo"), - son_next(700, "bar"), son_next(700, "qux"), + son_next(700, "bar"), son_next(750, "baz"), son_next(750, "foo"), - son_next(800, "bar"), son_next(800, "qux"), + son_next(800, "bar"), son_next(850, "baz"), son_next(900, "qux"), son_next(950, "foo") -- GitLab From 367987178430d53f55fe1cc318f54b486f7e584e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 23 Apr 2014 22:36:22 -0700 Subject: [PATCH 262/782] add is_subscribed checks and simplify elapsed calculation --- Rx/v2/src/rxcpp/operators/rx-map.hpp | 2 +- Rx/v2/test/subjects/subject.cpp | 22 ++++++++-------------- 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 91d6673..82825ee 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -50,7 +50,7 @@ struct map } template - void on_subscribe(Subscriber o) { + void on_subscribe(const Subscriber& o) { typedef Subscriber output_type; struct state_type diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index f765f03..d98bd6b 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -34,8 +34,7 @@ SCENARIO("for loop locks mutex", "[hide][for][mutex][perf]"){ ++c; } auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); + auto msElapsed = duration_cast(finish-start); std::cout << "loop mutex : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } @@ -64,8 +63,7 @@ SCENARIO("for loop calls observer", "[hide][for][observer][perf]"){ } o.on_completed(); auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); + auto msElapsed = duration_cast(finish-start); std::cout << "loop -> observer : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } } @@ -86,13 +84,12 @@ SCENARIO("for loop calls subscriber", "[hide][for][subscriber][perf]"){ auto o = rx::make_subscriber( [&c](int){++c;}, [](std::exception_ptr){abort();}); - for (int i = 0; i < onnextcalls; i++) { + for (int i = 0; i < onnextcalls && o.is_subscribed(); i++) { o.on_next(i); } o.on_completed(); auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); + auto msElapsed = duration_cast(finish-start); std::cout << "loop -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } } @@ -118,8 +115,7 @@ SCENARIO("range calls subscriber", "[hide][range][subscriber][perf]"){ [](std::exception_ptr){abort();}); auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); + auto msElapsed = duration_cast(finish-start); std::cout << "range -> subscriber : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } } @@ -175,7 +171,7 @@ SCENARIO("for loop calls subject", "[hide][for][subject][subjects][perf]"){ } auto start = clock::now(); - for (int i = 0; i < onnextcalls; i++) { + for (int i = 0; i < onnextcalls && o.is_subscribed(); i++) { #if RXCPP_DEBUG_SUBJECT_RACE if (*p != *c) abort(); (*p) += n; @@ -184,8 +180,7 @@ SCENARIO("for loop calls subject", "[hide][for][subject][subjects][perf]"){ } o.on_completed(); auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); + auto msElapsed = duration_cast(finish-start); std::cout << "loop -> subject : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } } @@ -249,8 +244,7 @@ SCENARIO("range calls subject", "[hide][range][subject][subjects][perf]"){ #endif .subscribe(o); auto finish = clock::now(); - auto msElapsed = duration_cast(finish.time_since_epoch()) - - duration_cast(start.time_since_epoch()); + auto msElapsed = duration_cast(finish-start); std::cout << "range -> subject : " << n << " subscribed, " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; } } -- GitLab From 15807b31b06a4558b55356a3d69c0287f6177f7d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 28 Apr 2014 07:08:36 -0700 Subject: [PATCH 263/782] initial shift to scheduler + worker --- Rx/v2/src/rxcpp/rx-observable.hpp | 8 +- Rx/v2/src/rxcpp/rx-predef.hpp | 13 + Rx/v2/src/rxcpp/rx-regulator.hpp | 2 +- Rx/v2/src/rxcpp/rx-scheduler.hpp | 434 +++++++++++++----- Rx/v2/src/rxcpp/rx-subscription.hpp | 2 +- .../src/rxcpp/schedulers/rx-currentthread.hpp | 147 +++--- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 34 +- Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 48 +- Rx/v2/src/rxcpp/sources/rx-range.hpp | 6 +- Rx/v2/test/operators/publish.cpp | 1 - Rx/v2/test/operators/take.cpp | 1 - 11 files changed, 482 insertions(+), 214 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 2573353..c6ce428 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -169,9 +169,11 @@ private: // make sure to let current_thread take ownership of the thread as early as possible. if (rxsc::current_thread::is_schedule_required()) { auto sc = rxsc::make_current_thread(); - sc.schedule(o.get_subscription(), [=](const rxsc::schedulable& scbl) { - safe_subscribe(); - }); + sc.create_worker(o.get_subscription()).schedule( + o.get_subscription(), + [=](const rxsc::schedulable& scbl) { + safe_subscribe(); + }); } else { // current_thread already owns this thread. safe_subscribe(); diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 41cb223..25a75c8 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -22,6 +22,19 @@ public: static const bool value = std::is_convertible::type>(0)), tag_action*>::value; }; +struct tag_worker {}; +template +class is_worker +{ + struct not_void {}; + template + static typename C::worker_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_worker*>::value; +}; + struct tag_scheduler {}; template class is_scheduler diff --git a/Rx/v2/src/rxcpp/rx-regulator.hpp b/Rx/v2/src/rxcpp/rx-regulator.hpp index e8bcdca..8a7b998 100644 --- a/Rx/v2/src/rxcpp/rx-regulator.hpp +++ b/Rx/v2/src/rxcpp/rx-regulator.hpp @@ -88,7 +88,7 @@ public: state->isresumed = true; auto resumewith = std::move(state->resumewith); auto local = state->resumewith; - state->resumewith = rxsc::schedulable::empty(local.get_scheduler()); + state->resumewith = rxsc::schedulable::empty(local.get_worker()); local.schedule(); } inline resumption get_resumption() { diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 93c6ed9..a57851c 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -11,6 +11,7 @@ namespace rxcpp { namespace schedulers { +class worker_interface; class scheduler_interface; namespace detail { @@ -18,6 +19,9 @@ namespace detail { class action_type; typedef std::shared_ptr action_ptr; +typedef std::shared_ptr worker_interface_ptr; +typedef std::shared_ptr const_worker_interface_ptr; + typedef std::shared_ptr scheduler_interface_ptr; typedef std::shared_ptr const_scheduler_interface_ptr; @@ -29,6 +33,8 @@ typedef std::shared_ptr const_scheduler_interface_ptr // allows the callback and the scheduler to share stack space that records // the request and the allowance without any virtual calls in the loop. +/// recursed is set on a schedulable by the action to allow the called +/// function to request to be rescheduled. class recursed { bool& isrequested; @@ -37,11 +43,14 @@ public: : isrequested(r) { } + /// request to be rescheduled inline void operator()() const { isrequested = true; } }; +/// recurse is passed to the action by the scheduler. +/// the action uses recurse to coordinate the scheduler and the function. class recurse { bool& isallowed; @@ -54,20 +63,25 @@ public: , requestor(isrequested) { } + /// does the scheduler allow tail-recursion now? inline bool is_allowed() const { return isallowed; } + /// did the function request to be recursed? inline bool is_requested() const { return isrequested; } + /// reset the function request. call before each call to the function. inline void reset() const { isrequested = false; } + /// get the recursed to set into the schedulable for the function to use to request recursion inline const recursed& get_recursed() const { return requestor; } }; +/// recursion is used by the scheduler to signal to each action whether tail recursion is allowed. class recursion { mutable bool isallowed; @@ -83,9 +97,11 @@ public: , recursor(isallowed) { } + /// set whether tail-recursion is allowed inline void reset(bool b = true) const { isallowed = b; } + /// get the recurse to pass into each action being called inline const recurse& get_recurse() const { return recursor; } @@ -99,20 +115,12 @@ struct action_base class schedulable; -namespace action_duration { - enum type { - invalid, - runs_short, - runs_long - }; -} - +/// action provides type-forgetting for a potentially recursive set of calls to a function that takes a schedulable class action : public action_base { typedef action this_type; detail::action_ptr inner; static detail::action_ptr shared_empty; - friend bool operator==(const action&, const action&); public: action() { @@ -122,12 +130,12 @@ public: { } + /// return the empty action inline static action empty() { return action(shared_empty); } - inline action_duration::type get_duration() const; - + /// call the function inline void operator()(const schedulable& s, const recurse& r) const; }; @@ -137,38 +145,27 @@ struct scheduler_base typedef tag_scheduler scheduler_tag; }; -class schedulable; +struct worker_base : public subscription_base +{ + typedef tag_worker worker_tag; +}; -class scheduler_interface - : public std::enable_shared_from_this +class worker_interface + : public std::enable_shared_from_this { - typedef scheduler_interface this_type; + typedef worker_interface this_type; public: typedef scheduler_base::clock_type clock_type; - virtual ~scheduler_interface() {} + virtual ~worker_interface() {} virtual clock_type::time_point now() const = 0; virtual void schedule(const schedulable& scbl) const = 0; - virtual void schedule(clock_type::duration when, const schedulable& scbl) const = 0; virtual void schedule(clock_type::time_point when, const schedulable& scbl) const = 0; }; - -struct schedulable_base : public subscription_base, public scheduler_base, public action_base -{ - typedef tag_schedulable schedulable_tag; -}; - -inline bool operator==(const action& lhs, const action& rhs) { - return lhs.inner == rhs.inner; -} -inline bool operator!=(const action& lhs, const action& rhs) { - return !(lhs == rhs); -} - namespace detail { template @@ -185,62 +182,195 @@ struct is_action_function } -class scheduler : public scheduler_base +/// a worker ensures that all scheduled actions on the same instance are executed in-order with no overlap +/// a worker ensures that all scheduled actions are unsubscribed when it is unsubscribed +/// some inner implementations will impose additional constraints on the execution of items. +class worker : public worker_base { - typedef scheduler this_type; - detail::scheduler_interface_ptr inner; - friend bool operator==(const scheduler&, const scheduler&); + typedef worker this_type; + detail::worker_interface_ptr inner; + composite_subscription lifetime; + friend bool operator==(const worker&, const worker&); public: typedef scheduler_base::clock_type clock_type; + typedef composite_subscription::shared_subscription shared_subscription; + typedef composite_subscription::weak_subscription weak_subscription; - scheduler() + worker() { } - explicit scheduler(detail::scheduler_interface_ptr i) - : inner(std::move(i)) + worker(composite_subscription cs, detail::const_worker_interface_ptr i) + : inner(std::const_pointer_cast(i)) + , lifetime(std::move(cs)) { } - explicit scheduler(detail::const_scheduler_interface_ptr i) - : inner(std::const_pointer_cast(i)) - { + + inline const composite_subscription& get_subscription() const { + return lifetime; + } + inline composite_subscription& get_subscription() { + return lifetime; + } + + // composite_subscription + // + inline bool is_subscribed() const { + return lifetime.is_subscribed(); + } + inline weak_subscription add(shared_subscription s) const { + return lifetime.add(std::move(s)); + } + inline weak_subscription add(dynamic_subscription s) const { + return lifetime.add(std::move(s)); + } + inline void remove(weak_subscription w) const { + return lifetime.remove(std::move(w)); + } + inline void clear() const { + return lifetime.clear(); + } + inline void unsubscribe() const { + return lifetime.unsubscribe(); } + // worker_interface + // + /// return the current time for this worker inline clock_type::time_point now() const { return inner->now(); } + /// insert the supplied schedulable to be run as soon as possible inline void schedule(const schedulable& scbl) const { - inner->schedule(scbl); + // force rebinding scbl to this worker + schedule_rebind(scbl); + } + + /// insert the supplied schedulable to be run at the time specified + inline void schedule(clock_type::time_point when, const schedulable& scbl) const { + // force rebinding scbl to this worker + schedule_rebind(when, scbl); } + + // helpers + // + + /// insert the supplied schedulable to be run at now() + the delay specified inline void schedule(clock_type::duration when, const schedulable& scbl) const { - inner->schedule(when, scbl); + // force rebinding scbl to this worker + schedule_rebind(now() + when, scbl); } - inline void schedule(clock_type::time_point when, const schedulable& scbl) const { - inner->schedule(when, scbl); + + /// insert the supplied schedulable to be run at the initial time specified and then again at initial + (N * period) + /// this will continue until the worker or schedulable is unsubscribed. + inline void schedule_periodically(clock_type::time_point initial, clock_type::duration period, const schedulable& scbl) const { + // force rebinding scbl to this worker + schedule_periodically_rebind(initial, period, scbl); } + /// insert the supplied schedulable to be run at now() + the initial delay specified and then again at now() + initial + (N * period) + /// this will continue until the worker or schedulable is unsubscribed. + inline void schedule_periodically(clock_type::duration initial, clock_type::duration period, const schedulable& scbl) const { + // force rebinding scbl to this worker + schedule_periodically_rebind(now() + initial, period, scbl); + } + + /// use the supplied arguments to make a schedulable and then insert it to be run template auto schedule(Arg0&& a0, ArgN&&... an) const -> typename std::enable_if< (detail::is_action_function::value || is_subscription::value) && !is_schedulable::value>::type; + template + /// use the supplied arguments to make a schedulable and then insert it to be run + void schedule_rebind(const schedulable& scbl, ArgN&&... an) const; + + /// use the supplied arguments to make a schedulable and then insert it to be run template - auto schedule(Arg0&& a0, ArgN&&... an) const + auto schedule(clock_type::time_point when, Arg0&& a0, ArgN&&... an) const -> typename std::enable_if< - !detail::is_action_function::value && - !is_subscription::value && - !is_scheduler::value && + (detail::is_action_function::value || + is_subscription::value) && !is_schedulable::value>::type; + /// use the supplied arguments to make a schedulable and then insert it to be run + template + void schedule_rebind(clock_type::time_point when, const schedulable& scbl, ArgN&&... an) const; + + /// use the supplied arguments to make a schedulable and then insert it to be run + template + auto schedule_periodically(clock_type::time_point initial, clock_type::duration period, Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type; + /// use the supplied arguments to make a schedulable and then insert it to be run + template + void schedule_periodically_rebind(clock_type::time_point initial, clock_type::duration period, const schedulable& scbl, ArgN&&... an) const; }; -inline bool operator==(const scheduler& lhs, const scheduler& rhs) { - return lhs.inner == rhs.inner; +inline bool operator==(const worker& lhs, const worker& rhs) { + return lhs.inner == rhs.inner && lhs.lifetime == rhs.lifetime; } -inline bool operator!=(const scheduler& lhs, const scheduler& rhs) { +inline bool operator!=(const worker& lhs, const worker& rhs) { return !(lhs == rhs); } +class scheduler_interface + : public std::enable_shared_from_this +{ + typedef scheduler_interface this_type; + +public: + typedef scheduler_base::clock_type clock_type; + + virtual ~scheduler_interface() {} + + virtual clock_type::time_point now() const = 0; + + virtual worker create_worker(composite_subscription cs) const = 0; +}; + + +struct schedulable_base : public subscription_base, public worker_base, public action_base +{ + typedef tag_schedulable schedulable_tag; +}; + +class scheduler : public scheduler_base +{ + typedef scheduler this_type; + detail::scheduler_interface_ptr inner; + friend bool operator==(const scheduler&, const scheduler&); +public: + typedef scheduler_base::clock_type clock_type; + + scheduler() + { + } + explicit scheduler(detail::scheduler_interface_ptr i) + : inner(std::move(i)) + { + } + explicit scheduler(detail::const_scheduler_interface_ptr i) + : inner(std::const_pointer_cast(i)) + { + } + + /// return the current time for this scheduler + inline clock_type::time_point now() const { + return inner->now(); + } + /// create a worker with a lifetime. + /// when the worker is unsubscribed all scheduled items will be unsubscribed. + /// items scheduled to a worker will be run one at a time. + /// scheduling order is preserved: when more than one item is scheduled for + /// time T then at time T they will be run in the order that they were scheduled. + inline worker create_worker(composite_subscription cs = composite_subscription()) const { + return inner->create_worker(cs); + } +}; + template inline scheduler make_scheduler() { return scheduler(std::static_pointer_cast(std::make_shared())); @@ -252,8 +382,10 @@ class schedulable : public schedulable_base typedef schedulable this_type; composite_subscription lifetime; - scheduler controller; + worker controller; action activity; + bool scoped; + composite_subscription::weak_subscription action_scope; struct detacher { @@ -320,13 +452,67 @@ public: typedef composite_subscription::shared_subscription shared_subscription; typedef scheduler_base::clock_type clock_type; + ~schedulable() + { + if (scoped) { + controller.remove(action_scope); + } + } schedulable() + : scoped(false) + { + } + schedulable(const schedulable& o) + : lifetime(o.lifetime) + , controller(o.controller) + , activity(o.activity) + , scoped(o.scoped) + , action_scope(o.scoped ? controller.add(lifetime) : weak_subscription()) { } - schedulable(composite_subscription cs, scheduler q, action a) - : lifetime(std::move(cs)) - , controller(std::move(q)) + schedulable(schedulable&& o) + : lifetime(std::move(o.lifetime)) + , controller(std::move(o.controller)) + , activity(std::move(o.activity)) + , scoped(o.scoped) + , action_scope(std::move(o.action_scope)) + { + o.scoped = false; + } + schedulable& operator =(schedulable o) { + using std::swap; + swap(lifetime, o.lifetime); + swap(controller, o.controller); + swap(activity, o.activity); + swap(scoped, o.scoped); + swap(action_scope, o.action_scope); + return *this; + } + + /// action and worker share lifetime + schedulable(worker q, action a) + : lifetime(q.get_subscription()) + , controller(q) , activity(std::move(a)) + , scoped(false) + { + } + /// action and worker have independent lifetimes + schedulable(composite_subscription cs, worker q, action a) + : lifetime(cs) + , controller(q) + , activity(std::move(a)) + , scoped(true) + , action_scope(q.add(cs)) + { + } + /// inherit lifetimes + schedulable(schedulable scbl, worker q, action a) + : lifetime(scbl.get_subscription()) + , controller(q) + , activity(std::move(a)) + , scoped(scbl.scoped) + , action_scope(scbl.scoped ? q.add(scbl.get_subscription()) : weak_subscription()) { } @@ -336,10 +522,10 @@ public: inline composite_subscription& get_subscription() { return lifetime; } - inline const scheduler& get_scheduler() const { + inline const worker& get_worker() const { return controller; } - inline scheduler& get_scheduler() { + inline worker& get_worker() { return controller; } inline const action& get_action() const { @@ -349,7 +535,7 @@ public: return activity; } - inline static schedulable empty(scheduler sc) { + inline static schedulable empty(worker sc) { return schedulable(composite_subscription::empty(), sc, action::empty()); } @@ -403,25 +589,26 @@ public: } /// put this on the queue of the stored scheduler to run asap inline void schedule() const { - controller.schedule(*this); - } - /// put this on the queue of the stored scheduler to run after a delay from now - inline void schedule(clock_type::duration when) const { - controller.schedule(when, *this); + if (is_subscribed()) { + controller.schedule(*this); + } } /// put this on the queue of the stored scheduler to run at the specified time inline void schedule(clock_type::time_point when) const { - controller.schedule(when, *this); + if (is_subscribed()) { + controller.schedule(when, *this); + } + } + /// put this on the queue of the stored scheduler to run after a delay from now + inline void schedule(clock_type::duration when) const { + if (is_subscribed()) { + controller.schedule(when, *this); + } } // action // - /// some schedulers care about how long an action will run - /// this is how an action declares its behavior - inline action_duration::type get_duration() const { - return activity.get_duration(); - } - /// + /// invokes the action inline void operator()(const recurse& r) const { if (!is_subscribed()) { abort(); @@ -432,15 +619,6 @@ public: } }; -inline bool operator==(const schedulable& lhs, const schedulable& rhs) { - return lhs.get_action() == rhs.get_action() && - lhs.get_scheduler() == rhs.get_scheduler() && - lhs.get_subscription() == rhs.get_subscription(); -} -inline bool operator!=(const schedulable& lhs, const schedulable& rhs) { - return !(lhs == rhs); -} - struct current_thread; namespace detail { @@ -454,7 +632,6 @@ public: typedef std::function function_type; private: - action_duration::type d; function_type f; public: @@ -462,16 +639,11 @@ public: { } - action_type(action_duration::type d, function_type f) - : d(d) - , f(std::move(f)) + action_type(function_type f) + : f(std::move(f)) { } - inline action_duration::type get_duration() const { - return d; - } - inline void operator()(const schedulable& s, const recurse& r) { if (!f) { abort(); @@ -482,11 +654,6 @@ public: } - -inline action_duration::type action::get_duration() const { - return inner->get_duration(); -} - inline void action::operator()(const schedulable& s, const recurse& r) const { (*inner)(s, r); } @@ -500,11 +667,10 @@ inline action make_action_empty() { } template -inline action make_action(F&& f, action_duration::type d = action_duration::runs_short) { +inline action make_action(F&& f) { static_assert(detail::is_action_function::value, "action function must be void(schedulable)"); auto fn = std::forward(f); return action(std::make_shared( - d, // tail-recurse inside of the virtual function call // until a new action, lifetime or scheduler is returned [fn](const schedulable& s, const recurse& r) { @@ -535,64 +701,96 @@ inline auto make_schedulable( return schedulable(std::move(scbl)); } -// action -// - template -auto make_schedulable(scheduler sc, F&& f, action_duration::type d = action_duration::runs_short) +auto make_schedulable(worker sc, F&& f) -> typename std::enable_if::value, schedulable>::type { - return schedulable(composite_subscription(), sc, make_action(std::forward(f), d)); + return schedulable(sc, make_action(std::forward(f))); } template -auto make_schedulable(scheduler sc, composite_subscription cs, F&& f, action_duration::type d = action_duration::runs_short) +auto make_schedulable(worker sc, composite_subscription cs, F&& f) -> typename std::enable_if::value, schedulable>::type { - return schedulable(cs, sc, make_action(std::forward(f), d)); + return schedulable(cs, sc, make_action(std::forward(f))); } template -auto make_schedulable(schedulable scbl, composite_subscription cs, F&& f, action_duration::type d = action_duration::runs_short) +auto make_schedulable(schedulable scbl, composite_subscription cs, F&& f) -> typename std::enable_if::value, schedulable>::type { - return schedulable(cs, scbl.get_scheduler(), make_action(std::forward(f), d)); + return schedulable(cs, scbl.get_worker(), make_action(std::forward(f))); } template -auto make_schedulable(schedulable scbl, scheduler sc, F&& f, action_duration::type d = action_duration::runs_short) +auto make_schedulable(schedulable scbl, worker sc, F&& f) -> typename std::enable_if::value, schedulable>::type { - return schedulable(scbl.get_subscription(), sc, make_action(std::forward(f), d)); + return schedulable(scbl, sc, make_action(std::forward(f))); } template -auto make_schedulable(schedulable scbl, F&& f, action_duration::type d = action_duration::runs_short) +auto make_schedulable(schedulable scbl, F&& f) -> typename std::enable_if::value, schedulable>::type { - return schedulable(scbl.get_subscription(), scbl.get_scheduler(), make_action(std::forward(f), d)); + return schedulable(scbl, scbl.get_worker(), make_action(std::forward(f))); } inline auto make_schedulable(schedulable scbl, composite_subscription cs) -> schedulable { - return schedulable(cs, scbl.get_scheduler(), scbl.get_action()); + return schedulable(cs, scbl.get_worker(), scbl.get_action()); } -inline auto make_schedulable(schedulable scbl, scheduler sc, composite_subscription cs) +inline auto make_schedulable(schedulable scbl, worker sc, composite_subscription cs) -> schedulable { return schedulable(cs, sc, scbl.get_action()); } -inline auto make_schedulable(schedulable scbl, scheduler sc) +inline auto make_schedulable(schedulable scbl, worker sc) -> schedulable { - return schedulable(composite_subscription(), sc, scbl.get_action()); + return schedulable(scbl, sc, scbl.get_action()); } template -auto scheduler::schedule(Arg0&& a0, ArgN&&... an) const +auto worker::schedule(Arg0&& a0, ArgN&&... an) const -> typename std::enable_if< (detail::is_action_function::value || is_subscription::value) && !is_schedulable::value>::type { - return this->schedule(make_schedulable(*this, std::forward(a0), std::forward(an)...)); + inner->schedule(make_schedulable(*this, std::forward(a0), std::forward(an)...)); +} +template +void worker::schedule_rebind(const schedulable& scbl, ArgN&&... an) const { + inner->schedule(make_schedulable(scbl, *this, std::forward(an)...)); } + template -auto scheduler::schedule(Arg0&& a0, ArgN&&... an) const +auto worker::schedule(clock_type::time_point when, Arg0&& a0, ArgN&&... an) const -> typename std::enable_if< - !detail::is_action_function::value && - !is_subscription::value && - !is_scheduler::value && + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type { + inner->schedule(when, make_schedulable(*this, std::forward(a0), std::forward(an)...)); +} +template +void worker::schedule_rebind(clock_type::time_point when, const schedulable& scbl, ArgN&&... an) const { + inner->schedule(when, make_schedulable(scbl, *this, std::forward(an)...)); +} + +template +auto worker::schedule_periodically(clock_type::time_point initial, clock_type::duration period, Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && !is_schedulable::value>::type { - return this->schedule(std::forward(a0), make_schedulable(*this, std::forward(an)...)); + schedule_periodically_rebind(initial, period, make_schedulable(*this, std::forward(a0), std::forward(an)...)); +} +template +void worker::schedule_periodically_rebind(clock_type::time_point initial, clock_type::duration period, const schedulable& scbl, ArgN&&... an) const { + std::shared_ptr target(new clock_type::time_point(initial)); + auto activity = make_schedulable(scbl, *this, std::forward(an)...); + auto periodic = make_schedulable( + activity, + [target, period, activity](schedulable self) { + // any recursion requests will be pushed to the scheduler queue + recursion r(false); + // call action + activity(r.get_recurse()); + + // schedule next occurance (if the action took longer than 'period' target will be in the past) + *target += period; + self.schedule(*target); + }); + inner->schedule(*target, periodic); } namespace detail { diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 8d11f4d..40700e8 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -183,7 +183,7 @@ private: inline void remove(weak_subscription w) { std::unique_lock guard(lock); - if (issubscribed) { + if (issubscribed && !w.expired()) { auto s = w.lock(); if (s) { diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index e819418..1f915f6 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -25,7 +25,7 @@ private: public: struct current_thread_queue_type { - scheduler sc; + std::shared_ptr w; recursion r; queue_item_time queue; }; @@ -38,8 +38,8 @@ private: public: - static scheduler get_scheduler() { - return !!current_thread_queue() ? current_thread_queue()->sc : scheduler(); + static std::shared_ptr get_worker_interface() { + return !!current_thread_queue() ? current_thread_queue()->w : std::shared_ptr(); } static recursion& get_recursion() { return current_thread_queue()->r; @@ -79,18 +79,18 @@ public: // disallow recursion state->r.reset(false); } - static scheduler ensure(scheduler sc) { + static std::shared_ptr ensure(std::shared_ptr w) { if (!!current_thread_queue()) { abort(); } // create and publish new queue current_thread_queue() = new current_thread_queue_type(); - current_thread_queue()->sc = sc; - return sc; + current_thread_queue()->w = w; + return w; } - static std::unique_ptr create(scheduler sc) { + static std::unique_ptr create(std::shared_ptr w) { std::unique_ptr result(new current_thread_queue_type()); - result->sc = std::move(sc); + result->w = std::move(w); return result; } static void set(current_thread_queue_type* queue) { @@ -123,7 +123,7 @@ private: typedef detail::action_queue queue; - struct derecurser : public scheduler_interface + struct derecurser : public worker_interface { private: typedef current_thread this_type; @@ -144,12 +144,77 @@ private: queue::push(queue::item_type(now(), scbl)); } - virtual void schedule(clock_type::duration when, const schedulable& scbl) const { - queue::push(queue::item_type(now() + when, scbl)); + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + queue::push(queue::item_type(when, scbl)); + } + }; + + struct current_worker : public worker_interface + { + private: + typedef current_thread this_type; + composite_subscription lifetime; + current_worker(const this_type&); + public: + explicit current_worker(composite_subscription cs) + : lifetime(std::move(cs)) + { + } + virtual ~current_worker() + { + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual void schedule(const schedulable& scbl) const { + schedule(now(), scbl); } virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + if (!scbl.is_subscribed()) { + return; + } + + { + auto wi = queue::get_worker_interface(); + // check ownership + if (!!wi) { + // already has an owner - delegate + return worker(lifetime, wi).schedule(when, scbl); + } + + // take ownership + queue::ensure(std::make_shared()); + } + // release ownership + RXCPP_UNWIND_AUTO([]{ + queue::destroy(); + }); + queue::push(queue::item_type(when, scbl)); + + const auto& recursor = queue::get_recursion().get_recurse(); + + // loop until queue is empty + for ( + auto when = queue::top().when; + (std::this_thread::sleep_until(when), true); + when = queue::top().when + ) { + auto what = queue::top().what; + + queue::pop(); + + if (what.is_subscribed()) { + what(recursor); + } + + if (queue::empty()) { + break; + } + } } }; @@ -161,67 +226,19 @@ public: { } - static bool is_schedule_required() { return queue::get_scheduler() == scheduler(); } - - virtual clock_type::time_point now() const { - return clock_type::now(); - } + static bool is_schedule_required() { return !queue::get_worker_interface(); } inline bool is_tail_recursion_allowed() const { return queue::empty(); } - virtual void schedule(const schedulable& scbl) const { - schedule(now(), scbl); - } - - virtual void schedule(clock_type::duration when, const schedulable& scbl) const { - schedule(now() + when, scbl); + virtual clock_type::time_point now() const { + return clock_type::now(); } - virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { - if (!scbl.is_subscribed()) { - return; - } - - auto sc = queue::get_scheduler(); - // check ownership - if (sc != scheduler()) - { - // already has an owner - delegate - return sc.schedule(when, scbl); - } - - // take ownership - - sc = queue::ensure(make_scheduler()); - RXCPP_UNWIND_AUTO([]{ - queue::destroy(); - }); - - queue::push(queue::item_type(when, scbl)); - - const auto& recursor = queue::get_recursion().get_recurse(); - - // loop until queue is empty - for ( - auto when = queue::top().when; - std::this_thread::sleep_until(when), true; - when = queue::top().when - ) - { - auto what = queue::top().what; - - queue::pop(); - - if (what.is_subscribed()) { - what(recursor); - } - - if (queue::empty()) { - break; - } - } + virtual worker create_worker(composite_subscription cs) const { + std::shared_ptr wi(new current_worker(cs)); + return worker(cs, wi); } }; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 443f7e8..d3308d5 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -23,6 +23,11 @@ public: using base::schedule_absolute; using base::schedule_relative; + virtual worker get_worker() const + { + return base::get_worker(); + } + virtual void schedule_absolute(long when, const schedulable& a) const { if (when <= base::clock_now) @@ -143,11 +148,12 @@ public: virtual void on_subscribe(subscriber o) const { sv.push_back(rxn::subscription(sc->clock())); auto index = sv.size() - 1; + auto controller = sc->create_worker(composite_subscription()); for (auto& message : mv) { auto n = message.value(); sc->schedule_relative(message.time(), make_schedulable( - scheduler(std::static_pointer_cast(sc)), + controller, [n, o](const schedulable& scbl) { if (o.is_subscribed()) { n->accept(o); @@ -195,10 +201,11 @@ public: : sc(sc) , mv(mv) { + auto controller = sc->create_worker(composite_subscription()); for (auto& message : mv) { auto n = message.value(); sc->schedule_absolute(message.time(), make_schedulable( - scheduler(std::static_pointer_cast(sc)), + controller, [this, n](const schedulable& scbl) { auto local = this->observers; for (auto& o : local) { @@ -306,17 +313,22 @@ public: tester->schedule_relative(when, a); } - template - typename std::enable_if::type, schedulable>::value, void>::type - schedule_absolute(long when, F f) const { - tester->schedule_absolute(when, make_schedulable(*this, f)); + template + auto schedule_absolute(long when, Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type { + tester->schedule_absolute(when, make_schedulable(tester->get_worker(), std::forward(a0), std::forward(an)...)); } - - template - typename std::enable_if::type, schedulable>::value, void>::type - schedule_relative(long when, F f) const { - tester->schedule_relative(when, make_schedulable(*this, f)); + template + auto schedule_relative(long when, Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type { + tester->schedule_relative(when, make_schedulable(tester->get_worker(), std::forward(a0), std::forward(an)...)); } template diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index b8fe30f..34fc8a3 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -22,6 +22,30 @@ private: mutable bool isenabled; + struct virtual_worker : public worker_interface + { + std::shared_ptr controller; + + virtual_worker(std::shared_ptr vb) + : controller(std::move(vb)) + { + } + + virtual clock_type::time_point now() const { + return controller->to_time_point(controller->clock_now); + } + + virtual void schedule(const schedulable& scbl) const { + controller->schedule_absolute(controller->clock_now, scbl); + } + + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + controller->schedule_absolute(controller->to_relative(when - now()), scbl); + } + }; + + std::shared_ptr<> + public: typedef Absolute absolute; typedef Relative relative; @@ -161,16 +185,11 @@ public: return to_time_point(clock_now); } - virtual void schedule(const schedulable& scbl) const { - schedule_absolute(clock_now, scbl); - } - - virtual void schedule(clock_type::duration when, const schedulable& scbl) const { - schedule_absolute(to_relative(when), scbl); - } - - virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { - schedule_absolute(to_relative(when - now()), scbl); + virtual worker create_worker(composite_subscription cs) const { + std::shared_ptr wi(new virtual_worker( + std::static_pointer_cast( + std::const_pointer_cast(shared_from_this())))); + return worker(cs, wi); } }; @@ -193,6 +212,8 @@ private: mutable queue_item_time queue; + worker controller; + public: virtual ~virtual_time() { @@ -201,12 +222,16 @@ public: protected: virtual_time() { + controller = base::create_worker(composite_subscription()); } explicit virtual_time(typename base::absolute initialClock) : base(initialClock) { + controller = base::create_worker(composite_subscription()); } + virtual worker get_worker() const {return controller;} + virtual item_type top() const { return queue.top(); } @@ -224,7 +249,8 @@ protected: { // use a separate subscription here so that a's subscription is not affected auto run = make_schedulable( - scheduler(this->shared_from_this()), + get_worker(), + composite_subscription(), [a](const schedulable& scbl) { rxsc::recursion r; r.reset(false); diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index 69d5984..4f2ff35 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -22,6 +22,7 @@ struct range : public source_base size_t remaining; ptrdiff_t step; rxsc::scheduler sc; + rxsc::worker w; }; state_type init; range(T b, size_t c, ptrdiff_t s, rxsc::scheduler sc) @@ -34,8 +35,9 @@ struct range : public source_base template void on_subscribe(Subscriber o) { auto state = std::make_shared(init); - state->sc.schedule( - o.get_subscription(), + // creates a worker whose lifetime is the same as this subscription + state->w = state->sc.create_worker(o.get_subscription()); + state->w.schedule( [=](const rxsc::schedulable& self){ if (state->remaining == 0) { o.on_completed(); diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 8d044f0..f043d18 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -54,7 +54,6 @@ SCENARIO("publish", "[publish][multicast][operators]"){ typedef rxn::subscription life; typedef m::recorded_type record; auto on_next = m::on_next; - auto on_error = m::on_error; auto on_completed = m::on_completed; auto subscribe = m::subscribe; diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index 7926668..6e8ed00 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -75,7 +75,6 @@ SCENARIO("take, complete after", "[take][operators]"){ typedef rxn::subscription life; typedef m::recorded_type record; auto on_next = m::on_next; - auto on_error = m::on_error; auto on_completed = m::on_completed; auto subscribe = m::subscribe; -- GitLab From 09b16daca270ed0ade1f41f76c0910d6442e95de Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Apr 2014 23:46:04 -0700 Subject: [PATCH 264/782] fix virtual_time and test scheduler --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 26 -- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 332 ++++++++++++------ Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp | 57 +-- Rx/v2/test/operators/filter.cpp | 23 +- Rx/v2/test/operators/flat_map.cpp | 25 +- Rx/v2/test/operators/map.cpp | 3 +- Rx/v2/test/operators/publish.cpp | 23 +- Rx/v2/test/operators/take.cpp | 66 ++-- Rx/v2/test/subjects/subject.cpp | 87 ++--- 9 files changed, 363 insertions(+), 279 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index a57851c..4b01c36 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -462,32 +462,6 @@ public: : scoped(false) { } - schedulable(const schedulable& o) - : lifetime(o.lifetime) - , controller(o.controller) - , activity(o.activity) - , scoped(o.scoped) - , action_scope(o.scoped ? controller.add(lifetime) : weak_subscription()) - { - } - schedulable(schedulable&& o) - : lifetime(std::move(o.lifetime)) - , controller(std::move(o.controller)) - , activity(std::move(o.activity)) - , scoped(o.scoped) - , action_scope(std::move(o.action_scope)) - { - o.scoped = false; - } - schedulable& operator =(schedulable o) { - using std::swap; - swap(lifetime, o.lifetime); - swap(controller, o.controller); - swap(activity, o.activity); - swap(scoped, o.scoped); - swap(action_scope, o.action_scope); - return *this; - } /// action and worker share lifetime schedulable(worker q, action a) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index d3308d5..411bd43 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -13,54 +13,141 @@ namespace schedulers { namespace detail { -class test_type : public virtual_time +class test_type : public scheduler_interface { public: - typedef virtual_time base; - typedef base::clock_type clock_type; - typedef std::shared_ptr shared; - using base::schedule_absolute; - using base::schedule_relative; + typedef scheduler_interface::clock_type clock_type; - virtual worker get_worker() const + struct test_type_state : public virtual_time { - return base::get_worker(); - } + typedef virtual_time base; + + using base::schedule_absolute; + using base::schedule_relative; + + clock_type::time_point now() const { + return to_time_point(clock_now); + } + + virtual void schedule_absolute(long when, const schedulable& a) const + { + if (when <= base::clock_now) + when = base::clock_now + 1; - virtual void schedule_absolute(long when, const schedulable& a) const + return base::schedule_absolute(when, a); + } + + virtual long add(long absolute, long relative) const + { + return absolute + relative; + } + + virtual clock_type::time_point to_time_point(long absolute) const + { + return clock_type::time_point(clock_type::duration(absolute)); + } + + virtual long to_relative(clock_type::duration d) const + { + return static_cast(d.count()); + } + }; + +private: + mutable std::shared_ptr state; + +public: + struct test_type_worker : public worker_interface { - if (when <= base::clock_now) - when = base::clock_now + 1; + mutable std::shared_ptr state; - return base::schedule_absolute(when, a); - } + typedef test_type_state::absolute absolute; + typedef test_type_state::relative relative; + + test_type_worker(std::shared_ptr st) + : state(std::move(st)) + { + } + + virtual clock_type::time_point now() const { + return state->now(); + } + + virtual void schedule(const schedulable& scbl) const { + state->schedule_absolute(state->clock(), scbl); + } + + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + state->schedule_absolute(state->to_relative(when - now()), scbl); + } + + + void schedule_absolute(absolute when, const schedulable& scbl) const { + state->schedule_absolute(when, scbl); + } + + void schedule_relative(relative when, const schedulable& scbl) const { + state->schedule_relative(when, scbl); + } + + bool is_enabled() const {return state->is_enabled();} + absolute clock() const {return state->clock();} + + void start() const + { + state->start(); + } + + void stop() const + { + state->stop(); + } + + void advance_to(absolute time) const + { + state->advance_to(time); + } - virtual long add(long absolute, long relative) const + void advance_by(relative time) const + { + state->advance_by(time); + } + + void sleep(relative time) const + { + state->sleep(time); + } + + template + subscriber> make_subscriber() const; + }; + +public: + test_type() + : state(new test_type_state()) { - return absolute + relative; } - virtual clock_type::time_point to_time_point(long absolute) const - { - return clock_type::time_point(clock_type::duration(absolute)); + virtual clock_type::time_point now() const { + return state->now(); } - virtual long to_relative(clock_type::duration d) const - { - return static_cast(d.count()); + virtual worker create_worker(composite_subscription cs) const { + std::shared_ptr wi(new test_type_worker(state)); + return worker(cs, wi); } - using base::start; + std::shared_ptr create_test_type_worker_interface() const { + std::shared_ptr wi(new test_type_worker(state)); + return wi; + } template rxt::testable_observable make_hot_observable(std::vector>>> messages) const; template rxt::testable_observable make_cold_observable(std::vector>>> messages) const; - - template - subscriber> make_subscriber() const; }; template @@ -71,12 +158,12 @@ class mock_observer typedef rxn::recorded recorded_type; public: - mock_observer(typename test_type::shared sc) + explicit mock_observer(std::shared_ptr sc) : sc(sc) { } - typename test_type::shared sc; + std::shared_ptr sc; std::vector m; virtual void on_subscribe(subscriber) const { @@ -92,12 +179,12 @@ public: }; template -subscriber> test_type::make_subscriber() const +subscriber> test_type::test_type_worker::make_subscriber() const { typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - std::shared_ptr> ts(new mock_observer(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())))); + std::shared_ptr> ts(new mock_observer(state)); return rxcpp::make_subscriber(rxt::testable_observer(ts, make_observer_dynamic( // on_next @@ -125,30 +212,32 @@ class cold_observable : public rxt::detail::test_subject_base { typedef cold_observable this_type; - typename test_type::shared sc; + std::shared_ptr sc; typedef rxn::recorded::type> recorded_type; mutable std::vector mv; mutable std::vector sv; + mutable worker controller; public: - cold_observable(typename test_type::shared sc, std::vector mv) + cold_observable(std::shared_ptr sc, worker w, std::vector mv) : sc(sc) , mv(std::move(mv)) + , controller(w) { } template - cold_observable(typename test_type::shared sc, Iterator begin, Iterator end) + cold_observable(std::shared_ptr sc, worker w, Iterator begin, Iterator end) : sc(sc) , mv(begin, end) + , controller(w) { } virtual void on_subscribe(subscriber o) const { sv.push_back(rxn::subscription(sc->clock())); auto index = sv.size() - 1; - auto controller = sc->create_worker(composite_subscription()); for (auto& message : mv) { auto n = message.value(); @@ -179,7 +268,7 @@ public: template rxt::testable_observable test_type::make_cold_observable(std::vector>>> messages) const { - auto co = std::shared_ptr>(new cold_observable(std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); + auto co = std::shared_ptr>(new cold_observable(state, create_worker(composite_subscription()), std::move(messages))); return rxt::testable_observable(co); } @@ -188,20 +277,21 @@ class hot_observable : public rxt::detail::test_subject_base { typedef hot_observable this_type; - typename test_type::shared sc; + std::shared_ptr sc; typedef rxn::recorded::type> recorded_type; typedef subscriber observer_type; mutable std::vector mv; mutable std::vector sv; mutable std::vector observers; + mutable worker controller; public: - hot_observable(typename test_type::shared sc, std::vector mv) + hot_observable(std::shared_ptr sc, worker w, std::vector mv) : sc(sc) , mv(mv) + , controller(w) { - auto controller = sc->create_worker(composite_subscription()); for (auto& message : mv) { auto n = message.value(); sc->schedule_absolute(message.time(), make_schedulable( @@ -240,18 +330,18 @@ public: template rxt::testable_observable test_type::make_hot_observable(std::vector>>> messages) const { - return rxt::testable_observable(std::make_shared>( - std::const_pointer_cast(std::static_pointer_cast(shared_from_this())), std::move(messages))); + return rxt::testable_observable( + std::make_shared>(state, create_worker(composite_subscription()), std::move(messages))); } } class test : public scheduler { - detail::test_type::shared tester; + std::shared_ptr tester; public: - explicit test(detail::test_type::shared t) + explicit test(std::shared_ptr t) : scheduler(std::static_pointer_cast(t)) , tester(t) { @@ -305,85 +395,110 @@ public: ~messages(); }; - void schedule_absolute(long when, const schedulable& a) const { - tester->schedule_absolute(when, a); - } + class test_worker : public worker + { + std::shared_ptr tester; + public: - void schedule_relative(long when, const schedulable& a) const { - tester->schedule_relative(when, a); - } + explicit test_worker(composite_subscription cs, std::shared_ptr t) + : worker(cs, std::static_pointer_cast(t)) + , tester(t) + { + } - template - auto schedule_absolute(long when, Arg0&& a0, ArgN&&... an) const - -> typename std::enable_if< - (detail::is_action_function::value || - is_subscription::value) && - !is_schedulable::value>::type { - tester->schedule_absolute(when, make_schedulable(tester->get_worker(), std::forward(a0), std::forward(an)...)); - } + void schedule_absolute(long when, const schedulable& a) const { + tester->schedule_absolute(when, a); + } - template - auto schedule_relative(long when, Arg0&& a0, ArgN&&... an) const - -> typename std::enable_if< - (detail::is_action_function::value || - is_subscription::value) && - !is_schedulable::value>::type { - tester->schedule_relative(when, make_schedulable(tester->get_worker(), std::forward(a0), std::forward(an)...)); - } + void schedule_relative(long when, const schedulable& a) const { + tester->schedule_relative(when, a); + } - template - auto start(F&& createSource, long created, long subscribed, long unsubscribed) const - -> subscriber> - { - typename std::decay::type createSrc = std::forward(createSource); + template + auto schedule_absolute(long when, Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type { + tester->schedule_absolute(when, make_schedulable(*this, std::forward(a0), std::forward(an)...)); + } - struct state_type - : public std::enable_shared_from_this - { - typedef decltype(std::forward(createSrc)()) source_type; + template + auto schedule_relative(long when, Arg0&& a0, ArgN&&... an) const + -> typename std::enable_if< + (detail::is_action_function::value || + is_subscription::value) && + !is_schedulable::value>::type { + tester->schedule_relative(when, make_schedulable(*this, std::forward(a0), std::forward(an)...)); + } - std::unique_ptr source; - subscriber> o; + template + auto start(F&& createSource, long created, long subscribed, long unsubscribed) const + -> subscriber> + { + typename std::decay::type createSrc = std::forward(createSource); - explicit state_type(subscriber> o) - : source() - , o(o) + struct state_type + : public std::enable_shared_from_this { - } - }; - std::shared_ptr state(new state_type(this->make_subscriber())); + typedef decltype(std::forward(createSrc)()) source_type; + + std::unique_ptr source; + subscriber> o; + + explicit state_type(subscriber> o) + : source() + , o(o) + { + } + }; + std::shared_ptr state(new state_type(this->make_subscriber())); + + schedule_absolute(created, [createSrc, state](const schedulable& scbl) { + state->source.reset(new typename state_type::source_type(createSrc())); + }); + schedule_absolute(subscribed, [state](const schedulable& scbl) { + state->source->subscribe(state->o); + }); + schedule_absolute(unsubscribed, [state](const schedulable& scbl) { + state->o.unsubscribe(); + }); + + tester->start(); + + return state->o; + } - schedule_absolute(created, [createSrc, state](const schedulable& scbl) { - state->source.reset(new typename state_type::source_type(createSrc())); - }); - schedule_absolute(subscribed, [state](const schedulable& scbl) { - state->source->subscribe(state->o); - }); - schedule_absolute(unsubscribed, [state](const schedulable& scbl) { - state->o.unsubscribe(); - }); + template + auto start(F&& createSource, long unsubscribed) const + -> subscriber> + { + return start(std::forward(createSource), created_time, subscribed_time, unsubscribed); + } - tester->start(); + template + auto start(F&& createSource) const + -> subscriber> + { + return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); + } - return state->o; - } + void start() const { + tester->start(); + } - template - auto start(F&& createSource, long unsubscribed) const - -> subscriber> - { - return start(std::forward(createSource), created_time, subscribed_time, unsubscribed); - } + template + subscriber> make_subscriber() const { + return tester->make_subscriber(); + } + }; - template - auto start(F&& createSource) const - -> subscriber> - { - return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); + clock_type::time_point now() const { + return tester->now(); } - void start() const { - tester->start(); + test_worker create_worker(composite_subscription cs = composite_subscription()) const { + return test_worker(cs, tester->create_test_type_worker_interface()); } template @@ -407,11 +522,6 @@ public: -> decltype(tester->make_cold_observable(std::vector())) { return tester->make_cold_observable(rxu::to_vector(arr)); } - - template - subscriber> make_subscriber() const { - return tester->make_subscriber(); - } }; template diff --git a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp index 34fc8a3..bc42e5c 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-virtualtime.hpp @@ -14,7 +14,7 @@ namespace schedulers { namespace detail { template -struct virtual_time_base : public scheduler_interface +struct virtual_time_base : std::enable_shared_from_this> { private: typedef virtual_time_base this_type; @@ -22,30 +22,6 @@ private: mutable bool isenabled; - struct virtual_worker : public worker_interface - { - std::shared_ptr controller; - - virtual_worker(std::shared_ptr vb) - : controller(std::move(vb)) - { - } - - virtual clock_type::time_point now() const { - return controller->to_time_point(controller->clock_now); - } - - virtual void schedule(const schedulable& scbl) const { - controller->schedule_absolute(controller->clock_now, scbl); - } - - virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { - controller->schedule_absolute(controller->to_relative(when - now()), scbl); - } - }; - - std::shared_ptr<> - public: typedef Absolute absolute; typedef Relative relative; @@ -80,6 +56,7 @@ protected: virtual bool empty() const =0; public: + virtual void schedule_absolute(absolute, const schedulable&) const =0; virtual void schedule_relative(relative when, const schedulable& a) const { @@ -129,6 +106,7 @@ public: if (!isenabled) { isenabled = true; + rxsc::recursion r; while (!empty() && isenabled) { auto next = top(); pop(); @@ -136,7 +114,7 @@ public: if (next.when > clock_now) { clock_now = next.when; } - next.what.get_action()(next.what); + next.what(r.get_recurse()); } else { isenabled = false; @@ -181,28 +159,13 @@ public: clock_now = dt; } - virtual clock_type::time_point now() const { - return to_time_point(clock_now); - } - - virtual worker create_worker(composite_subscription cs) const { - std::shared_ptr wi(new virtual_worker( - std::static_pointer_cast( - std::const_pointer_cast(shared_from_this())))); - return worker(cs, wi); - } - }; } template -class virtual_time : public detail::virtual_time_base +struct virtual_time : public detail::virtual_time_base { -private: - typedef virtual_time this_type; - virtual_time(const this_type&); - typedef detail::virtual_time_base base; typedef typename base::item_type item_type; @@ -212,8 +175,6 @@ private: mutable queue_item_time queue; - worker controller; - public: virtual ~virtual_time() { @@ -222,16 +183,12 @@ public: protected: virtual_time() { - controller = base::create_worker(composite_subscription()); } explicit virtual_time(typename base::absolute initialClock) : base(initialClock) { - controller = base::create_worker(composite_subscription()); } - virtual worker get_worker() const {return controller;} - virtual item_type top() const { return queue.top(); } @@ -249,7 +206,7 @@ protected: { // use a separate subscription here so that a's subscription is not affected auto run = make_schedulable( - get_worker(), + a.get_worker(), composite_subscription(), [a](const schedulable& scbl) { rxsc::recursion r; @@ -261,10 +218,10 @@ protected: }); queue.push(item_type(when, run)); } - }; + } } diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index ac101ef..3e9e61d 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -31,6 +31,7 @@ bool IsPrime(int x) SCENARIO("filter stops on completion", "[filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -61,7 +62,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ auto xs = sc.make_hot_observable(messages); WHEN("filtered to ints that are primes"){ - auto res = sc.start( + auto res = w.start( [&xs, &invoked]() { #if 0 && RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -119,6 +120,7 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -146,7 +148,7 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ WHEN("filtered to ints that are primes"){ - auto res = sc.start( + auto res = w.start( [&xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -199,6 +201,7 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ SCENARIO("filter stops on error", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -232,7 +235,7 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ WHEN("filtered to ints that are primes"){ - auto res = sc.start( + auto res = w.start( [xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -286,6 +289,7 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -319,7 +323,7 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ WHEN("filtered to ints that are primes"){ - auto res = sc.start( + auto res = w.start( [ex, xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -377,6 +381,7 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -406,13 +411,13 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") }; auto xs = sc.make_hot_observable(rxu::to_vector(messages)); - auto res = sc.make_subscriber(); + auto res = w.make_subscriber(); rx::observable> ys; WHEN("filtered to ints that are primes"){ - sc.schedule_absolute(rxsc::test::created_time, + w.schedule_absolute(rxsc::test::created_time, [&invoked, &res, &ys, &xs](const rxsc::schedulable& scbl) { #if RXCPP_USE_OBSERVABLE_MEMBERS ys = xs @@ -433,15 +438,15 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") #endif }); - sc.schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl) { + w.schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl) { ys.subscribe(res); }); - sc.schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl) { + w.schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl) { res.unsubscribe(); }); - sc.start(); + w.start(); THEN("the output only contains primes"){ record items[] = { diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 7e6401e..ead0b0e 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 500; +static const int static_tripletCount = 2; SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -32,6 +32,7 @@ SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ for(int y = x; y <= z; ++y) { ++c; + std::cout << z << "," << y << "," << x << std::endl; if(x*x + y*y == z*z) { //result += (x + y + z); @@ -60,6 +61,7 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ using namespace std::chrono; typedef steady_clock clock; + std::vector> tried; int c = 0; int ct = 0; int n = 1; @@ -67,10 +69,12 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ auto triples = rxs::range(1) .flat_map( - [&c](int z){ return rxs::range(1, z) + [&c, &tried](int z){ return rxs::range(1, z) .flat_map( - [&c, z](int x){ return rxs::range(x, z) - .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) + [&c, &tried, z](int x){ return rxs::range(x, z) + .filter([&c, &tried, z, x](int y){++c; + tried.push_back(std::make_tuple(z, y, x)); + return x*x + y*y == z*z;}) .map([z, x](int y){return std::make_tuple(x, y, z);});}, [](int x, std::tuple triplet){return triplet;});}, [](int z, std::tuple triplet){return triplet;}); @@ -81,6 +85,10 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ //int x,y,z; std::tie(x,y,z) = triplet; std::cout << x << "," << y << "," << z << std::endl; }, [](std::exception_ptr){abort();}); + std::sort(tried.begin(), tried.end()); + for (auto& t : tried) { + int x,y,z; std::tie(z,y,x) = t; std::cout << z << "," << y << "," << x << std::endl; + } auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); @@ -93,6 +101,7 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxsc::test::messages ms; typedef rxn::subscription life; @@ -127,7 +136,7 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ WHEN("each int is mapped to the strings"){ - auto res = sc.start( + auto res = w.start( [&]() { return xs .flat_map( @@ -193,6 +202,7 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxsc::test::messages ms; typedef rxn::subscription life; @@ -227,7 +237,7 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ WHEN("each int is mapped to the strings"){ - auto res = sc.start( + auto res = w.start( [&]() { return xs .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) @@ -294,6 +304,7 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxsc::test::messages ms; typedef rxn::subscription life; @@ -330,7 +341,7 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ WHEN("each int is mapped to the strings"){ - auto res = sc.start( + auto res = w.start( [&]() { return xs .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) diff --git a/Rx/v2/test/operators/map.cpp b/Rx/v2/test/operators/map.cpp index 354fd24..db53387 100644 --- a/Rx/v2/test/operators/map.cpp +++ b/Rx/v2/test/operators/map.cpp @@ -16,6 +16,7 @@ namespace rxt=rxcpp::test; SCENARIO("map stops on completion", "[map][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -41,7 +42,7 @@ SCENARIO("map stops on completion", "[map][operators]"){ WHEN("mapped to ints that are one larger"){ - auto res = sc.start( + auto res = w.start( [xs, &invoked]() { return xs .map([&invoked](int x) { diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index f043d18..02d799b 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -50,6 +50,7 @@ SCENARIO("publish range", "[hide][range][subject][publish][operators]"){ SCENARIO("publish", "[publish][multicast][operators]"){ GIVEN("a test hot observable of longs"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -77,24 +78,24 @@ SCENARIO("publish", "[publish][multicast][operators]"){ }; auto xs = sc.make_hot_observable(messages); - auto res = sc.make_subscriber(); + auto res = w.make_subscriber(); rx::connectable_observable ys; WHEN("subscribed and then connected"){ - sc.schedule_absolute(rxsc::test::created_time, + w.schedule_absolute(rxsc::test::created_time, [&invoked, &ys, &xs](const rxsc::schedulable& scbl){ ys = xs.publish().as_dynamic(); //ys = xs.publish_last().as_dynamic(); }); - sc.schedule_absolute(rxsc::test::subscribed_time, + w.schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl){ ys.subscribe(res); }); - sc.schedule_absolute(rxsc::test::unsubscribed_time, + w.schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl){ res.unsubscribe(); }); @@ -102,11 +103,11 @@ SCENARIO("publish", "[publish][multicast][operators]"){ { rx::composite_subscription connection; - sc.schedule_absolute(300, + w.schedule_absolute(300, [connection, &ys](const rxsc::schedulable& scbl){ ys.connect(connection); }); - sc.schedule_absolute(400, + w.schedule_absolute(400, [connection](const rxsc::schedulable& scbl){ connection.unsubscribe(); }); @@ -115,11 +116,11 @@ SCENARIO("publish", "[publish][multicast][operators]"){ { rx::composite_subscription connection; - sc.schedule_absolute(500, + w.schedule_absolute(500, [connection, &ys](const rxsc::schedulable& scbl){ ys.connect(connection); }); - sc.schedule_absolute(550, + w.schedule_absolute(550, [connection](const rxsc::schedulable& scbl){ connection.unsubscribe(); }); @@ -128,17 +129,17 @@ SCENARIO("publish", "[publish][multicast][operators]"){ { rx::composite_subscription connection; - sc.schedule_absolute(650, + w.schedule_absolute(650, [connection, &ys](const rxsc::schedulable& scbl){ ys.connect(connection); }); - sc.schedule_absolute(800, + w.schedule_absolute(800, [connection](const rxsc::schedulable& scbl){ connection.unsubscribe(); }); } - sc.start(); + w.start(); THEN("the output only contains items sent while subscribed"){ record items[] = { diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index 6e8ed00..e44bd5b 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -15,6 +15,7 @@ namespace rxt=rxcpp::test; SCENARIO("take 2", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -35,7 +36,7 @@ SCENARIO("take 2", "[take][operators]"){ WHEN("2 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(2) @@ -71,6 +72,7 @@ SCENARIO("take 2", "[take][operators]"){ SCENARIO("take, complete after", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -104,7 +106,7 @@ SCENARIO("take, complete after", "[take][operators]"){ WHEN("20 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(20) @@ -155,6 +157,7 @@ SCENARIO("take, complete after", "[take][operators]"){ SCENARIO("take, complete same", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -189,7 +192,7 @@ SCENARIO("take, complete same", "[take][operators]"){ WHEN("17 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(17) @@ -240,6 +243,7 @@ SCENARIO("take, complete same", "[take][operators]"){ SCENARIO("take, complete before", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -274,7 +278,7 @@ SCENARIO("take, complete before", "[take][operators]"){ WHEN("10 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(10) @@ -318,6 +322,7 @@ SCENARIO("take, complete before", "[take][operators]"){ SCENARIO("take, error after", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -354,7 +359,7 @@ SCENARIO("take, error after", "[take][operators]"){ WHEN("20 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(20) @@ -405,6 +410,7 @@ SCENARIO("take, error after", "[take][operators]"){ SCENARIO("take, error same", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -439,7 +445,7 @@ SCENARIO("take, error same", "[take][operators]"){ WHEN("17 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(17) @@ -490,6 +496,7 @@ SCENARIO("take, error same", "[take][operators]"){ SCENARIO("take, error before", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -524,7 +531,7 @@ SCENARIO("take, error before", "[take][operators]"){ WHEN("3 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(3) @@ -561,6 +568,7 @@ SCENARIO("take, error before", "[take][operators]"){ SCENARIO("take, dispose before", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -594,7 +602,7 @@ SCENARIO("take, dispose before", "[take][operators]"){ WHEN("3 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(3) @@ -630,6 +638,7 @@ SCENARIO("take, dispose before", "[take][operators]"){ SCENARIO("take, dispose after", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -663,7 +672,7 @@ SCENARIO("take, dispose after", "[take][operators]"){ WHEN("3 values are taken"){ - auto res = sc.start( + auto res = w.start( [xs]() { return xs .take(3) @@ -703,6 +712,7 @@ SCENARIO("take, dispose after", "[take][operators]"){ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -730,7 +740,7 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [xs, ys]() { return xs .take_until(ys) @@ -775,6 +785,7 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -802,7 +813,7 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -847,6 +858,7 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -875,7 +887,7 @@ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]") WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -920,6 +932,7 @@ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]") SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -946,7 +959,7 @@ SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -993,6 +1006,7 @@ SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1018,7 +1032,7 @@ SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1065,6 +1079,7 @@ SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1087,7 +1102,7 @@ SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1130,6 +1145,7 @@ SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1153,7 +1169,7 @@ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1196,6 +1212,7 @@ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1217,7 +1234,7 @@ SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1257,6 +1274,7 @@ SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1277,7 +1295,7 @@ SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1317,6 +1335,7 @@ SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ SCENARIO("take_until, preempt before first produced", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1341,7 +1360,7 @@ SCENARIO("take_until, preempt before first produced", "[take_until][take][operat WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1384,6 +1403,7 @@ SCENARIO("take_until, preempt before first produced", "[take_until][take][operat SCENARIO("take_until, preempt before first produced, remain silent and proper unsubscribed", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1410,7 +1430,7 @@ SCENARIO("take_until, preempt before first produced, remain silent and proper un WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r, &sourceNotDisposed]() { return l .map([&sourceNotDisposed](int v){sourceNotDisposed = true; return v;}) @@ -1442,6 +1462,7 @@ SCENARIO("take_until, preempt before first produced, remain silent and proper un SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1468,7 +1489,7 @@ SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal" WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r, &signalNotDisposed]() { return l .take_until(r @@ -1501,6 +1522,7 @@ SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal" SCENARIO("take_until, error some", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -1525,7 +1547,7 @@ SCENARIO("take_until, error some", "[take_until][take][operators]"){ WHEN("one is taken until the other emits a marble"){ - auto res = sc.start( + auto res = w.start( [l, r]() { return l .take_until(r) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index d98bd6b..ca75e59 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -256,6 +256,7 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -279,40 +280,40 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ rxsub::subject s; - auto results1 = sc.make_subscriber(); + auto results1 = w.make_subscriber(); - auto results2 = sc.make_subscriber(); + auto results2 = w.make_subscriber(); - auto results3 = sc.make_subscriber(); + auto results3 = w.make_subscriber(); WHEN("multicasting an infinite source"){ auto o = s.get_subscriber(); - sc.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ s = rxsub::subject(); o = s.get_subscriber();}); - sc.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ xs.subscribe(o);}); - sc.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + w.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ o.unsubscribe();}); - sc.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results1);}); - sc.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results2);}); - sc.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results3);}); - sc.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ results2.unsubscribe();}); - sc.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ results3.unsubscribe();}); - sc.start(); + w.start(); THEN("result1 contains expected messages"){ record items[] = { @@ -353,6 +354,7 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ GIVEN("a subject and an finite source"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -377,40 +379,40 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ rxsub::subject s; - auto results1 = sc.make_subscriber(); + auto results1 = w.make_subscriber(); - auto results2 = sc.make_subscriber(); + auto results2 = w.make_subscriber(); - auto results3 = sc.make_subscriber(); + auto results3 = w.make_subscriber(); WHEN("multicasting an infinite source"){ auto o = s.get_subscriber(); - sc.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ s = rxsub::subject(); o = s.get_subscriber();}); - sc.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ xs.subscribe(o);}); - sc.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + w.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ o.unsubscribe();}); - sc.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results1);}); - sc.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results2);}); - sc.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results3);}); - sc.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ results2.unsubscribe();}); - sc.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ results3.unsubscribe();}); - sc.start(); + w.start(); THEN("result1 contains expected messages"){ record items[] = { @@ -452,6 +454,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ GIVEN("a subject and a source with an error"){ auto sc = rxsc::make_test(); + auto w = sc.create_worker(); typedef rxsc::test::messages m; typedef rxn::subscription life; typedef m::recorded_type record; @@ -478,40 +481,40 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ rxsub::subject s; - auto results1 = sc.make_subscriber(); + auto results1 = w.make_subscriber(); - auto results2 = sc.make_subscriber(); + auto results2 = w.make_subscriber(); - auto results3 = sc.make_subscriber(); + auto results3 = w.make_subscriber(); WHEN("multicasting an infinite source"){ auto o = s.get_subscriber(); - sc.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ s = rxsub::subject(); o = s.get_subscriber();}); - sc.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ xs.subscribe(o);}); - sc.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + w.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ o.unsubscribe();}); - sc.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results1);}); - sc.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results2);}); - sc.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ s.get_observable().subscribe(results3);}); - sc.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ results2.unsubscribe();}); - sc.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ results1.unsubscribe();}); - sc.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ results3.unsubscribe();}); - sc.start(); + w.start(); THEN("result1 contains expected messages"){ record items[] = { -- GitLab From 4246c348b0f0e883eaef7d97a1e8ffa8bd24f5ed Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 30 Apr 2014 01:11:08 -0700 Subject: [PATCH 265/782] adding immediate scheduler --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 1 + Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 83 +++++++++++++++++++++ 2 files changed, 84 insertions(+) create mode 100644 Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 4b01c36..a59532d 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -847,6 +847,7 @@ namespace rxsc=schedulers; } #include "schedulers/rx-currentthread.hpp" +#include "schedulers/rx-immediate.hpp" #include "schedulers/rx-virtualtime.hpp" #endif diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp new file mode 100644 index 0000000..c93a6c3 --- /dev/null +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -0,0 +1,83 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_IMMEDIATE_HPP) +#define RXCPP_RX_SCHEDULER_IMMEDIATE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +struct immediate : public scheduler_interface +{ +private: + typedef immediate this_type; + immediate(const this_type&); + + struct immediate_worker : public worker_interface + { + private: + typedef immediate this_type; + immediate_worker(const this_type&); + public: + virtual ~immediate_worker() + { + } + immediate_worker() + { + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual void schedule(const schedulable& scbl) const { + if (scbl.is_subscribed()) { + // allow recursion + recursion r(true); + scbl(r.get_recurse()); + } + } + + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + std::this_thread::sleep_until(when); + if (scbl.is_subscribed()) { + // allow recursion + recursion r(true); + scbl(r.get_recurse()); + } + } + }; + + std::shared_ptr wi; + +public: + immediate() + : wi(new immediate_worker()) + { + } + virtual ~immediate() + { + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual worker create_worker(composite_subscription cs) const { + return worker(cs, wi); + } +}; + +inline scheduler make_immediate() { + return make_scheduler(); +} + +} + +} + +#endif -- GitLab From 90a17668d25a7857dc552a9108bdf4f3425124b4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 30 Apr 2014 01:12:47 -0700 Subject: [PATCH 266/782] fix range to go from first to last --- Rx/v2/src/rxcpp/rx-observable.hpp | 4 ++-- Rx/v2/src/rxcpp/sources/rx-range.hpp | 31 ++++++++++++++++++---------- Rx/v2/test/subjects/subject.cpp | 4 ++-- 3 files changed, 24 insertions(+), 15 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index c6ce428..26fd032 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -322,10 +322,10 @@ class observable ~observable(); public: template - static auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) + static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) -> observable> { return observable>( - rxs::detail::range(start, count, step, sc)); + rxs::detail::range(first, last, step, sc)); } }; diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index 4f2ff35..9edc451 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -19,16 +19,16 @@ struct range : public source_base struct state_type { T next; - size_t remaining; + T last; ptrdiff_t step; rxsc::scheduler sc; rxsc::worker w; }; state_type init; - range(T b, size_t c, ptrdiff_t s, rxsc::scheduler sc) + range(T f, T l, ptrdiff_t s, rxsc::scheduler sc) { - init.next = b; - init.remaining = c; + init.next = f; + init.last = l; init.step = s; init.sc = sc; } @@ -39,18 +39,21 @@ struct range : public source_base state->w = state->sc.create_worker(o.get_subscription()); state->w.schedule( [=](const rxsc::schedulable& self){ - if (state->remaining == 0) { - o.on_completed(); - // o is unsubscribed - } if (!o.is_subscribed()) { // terminate loop return; } // send next value - --state->remaining; o.on_next(state->next); + if (std::abs(state->last - state->next) < std::abs(state->step)) { + if (state->last != state->next) { + o.on_next(state->last); + } + o.on_completed(); + // o is unsubscribed + return; + } state->next = static_cast(state->step + state->next); // tail recurse this same action to continue loop @@ -62,10 +65,16 @@ struct range : public source_base } template -auto range(T start = 0, size_t count = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) +auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable> { + return observable>( + detail::range(first, last, step, sc)); +} +template +auto range(T first = 0, rxsc::scheduler sc = rxsc::make_current_thread()) -> observable> { return observable>( - detail::range(start, count, step, sc)); + detail::range(first, std::numeric_limits::max(), 1, sc)); } } diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index ca75e59..9dc1b7e 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -108,7 +108,7 @@ SCENARIO("range calls subscriber", "[hide][range][subscriber][perf]"){ c = 0; auto start = clock::now(); - rxs::range(0, onnextcalls).subscribe( + rxs::range(1, onnextcalls).subscribe( [&c](int){ ++c; }, @@ -234,7 +234,7 @@ SCENARIO("range calls subject", "[hide][range][subject][subjects][perf]"){ } auto start = clock::now(); - rxs::range(0, onnextcalls) + rxs::range(1, onnextcalls) #if RXCPP_DEBUG_SUBJECT_RACE .filter([c, p, n](int){ if (*p != *c) abort(); -- GitLab From 47d93700bc4634325006736d93af8656f1f41b1c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 30 Apr 2014 01:14:37 -0700 Subject: [PATCH 267/782] use immediate scheduler for pythagorian tests --- Rx/v2/test/operators/flat_map.cpp | 31 +++++++++++-------------------- 1 file changed, 11 insertions(+), 20 deletions(-) diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index ead0b0e..b5b9053 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 2; +static const int static_tripletCount = 500; SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -32,11 +32,8 @@ SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ for(int y = x; y <= z; ++y) { ++c; - std::cout << z << "," << y << "," << x << std::endl; if(x*x + y*y == z*z) { - //result += (x + y + z); - //std::cout << x << "," << y << "," << z << std::endl; ++ct; if(ct == tripletCount) goto done; @@ -48,7 +45,7 @@ SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; } } @@ -61,38 +58,32 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ using namespace std::chrono; typedef steady_clock clock; - std::vector> tried; + auto sc = rxsc::make_immediate(); + //auto sc = rxsc::make_current_thread(); + int c = 0; int ct = 0; int n = 1; auto start = clock::now(); auto triples = - rxs::range(1) + rxs::range(1, sc) .flat_map( - [&c, &tried](int z){ return rxs::range(1, z) + [&c, sc](int z){ return rxs::range(1, z, 1, sc) .flat_map( - [&c, &tried, z](int x){ return rxs::range(x, z) - .filter([&c, &tried, z, x](int y){++c; - tried.push_back(std::make_tuple(z, y, x)); - return x*x + y*y == z*z;}) + [&c, sc, z](int x){ return rxs::range(x, z, 1, sc) + .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) .map([z, x](int y){return std::make_tuple(x, y, z);});}, [](int x, std::tuple triplet){return triplet;});}, [](int z, std::tuple triplet){return triplet;}); triples .take(tripletCount) .subscribe( - [&ct](std::tuple triplet){++ct; - //int x,y,z; std::tie(x,y,z) = triplet; std::cout << x << "," << y << "," << z << std::endl; - }, + [&ct](std::tuple triplet){++ct;}, [](std::exception_ptr){abort();}); - std::sort(tried.begin(), tried.end()); - for (auto& t : tried) { - int x,y,z; std::tie(z,y,x) = t; std::cout << z << "," << y << "," << x << std::endl; - } auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; } } -- GitLab From a4b50ef61711c952f3e230cf6593d8857c67b3a1 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 30 Apr 2014 23:11:58 -0700 Subject: [PATCH 268/782] adding perf comparison for async observer options --- Rx/v2/test/subjects/subject.cpp | 154 +++++++++++++++++++++++++++++++- 1 file changed, 153 insertions(+), 1 deletion(-) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 9dc1b7e..21bdf25 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -15,8 +15,11 @@ namespace rxt=rxcpp::test; #include "catch.hpp" +#include + const int static_onnextcalls = 100000000; +int aliased = 0; SCENARIO("for loop locks mutex", "[hide][for][mutex][perf]"){ const int& onnextcalls = static_onnextcalls; @@ -41,7 +44,156 @@ SCENARIO("for loop locks mutex", "[hide][for][mutex][perf]"){ } } -int aliased = 0; +namespace syncwithvoid { +template +class sync_subscriber +{ +public: + OnNext onnext; + bool issubscribed; + explicit sync_subscriber(OnNext on) + : onnext(on) + , issubscribed(true) + { + } + bool is_subscribed() {return issubscribed;} + void unsubscribe() {issubscribed = false;} + void on_next(T v) { + onnext(v); + } +}; +} +SCENARIO("for loop calls void on_next(int)", "[hide][for][asyncobserver][baseline][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop"){ + WHEN("calling on_next 100 million times"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto c = std::addressof(aliased); + *c = 0; + int n = 1; + auto start = clock::now(); + auto onnext = [c](int){++*c;}; + syncwithvoid::sync_subscriber scbr(onnext); + for (int i = 0; i < onnextcalls && scbr.is_subscribed(); i++) { + scbr.on_next(i); + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "loop void : " << n << " subscribed, " << *c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} + +namespace asyncwithready { +class ready +{ +public: + typedef std::function onthen_type; + std::function setthen; + bool is_ready() {return !setthen;} + void then(onthen_type ot) { + if (is_ready()) { + abort(); + } + setthen(ot); + } +}; +template +class async_subscriber +{ +public: + OnNext onnext; + bool issubscribed; + explicit async_subscriber(OnNext on) + : onnext(on) + , issubscribed(true) + { + } + bool is_subscribed() {return issubscribed;} + void unsubscribe() {issubscribed = false;} + ready on_next(T v) { + onnext(v); return ready();} +}; +} +SCENARIO("for loop calls ready on_next(int)", "[hide][for][asyncobserver][ready][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop"){ + WHEN("calling on_next 100 million times"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto c = std::addressof(aliased); + *c = 0; + int n = 1; + auto start = clock::now(); + auto onnext = [&c](int){++*c;}; + asyncwithready::async_subscriber scbr(onnext); + for (int i = 0; i < onnextcalls && scbr.is_subscribed(); i++) { + auto controller = scbr.on_next(i); + if (!controller.is_ready()) { + controller.then([](){ + // todo continue + }); + } + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "loop ready : " << n << " subscribed, " << *c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} + +namespace asyncwithfuture { +class unit {}; +template +class async_subscriber +{ +public: + OnNext onnext; + bool issubscribed; + explicit async_subscriber(OnNext on) + : onnext(on) + , issubscribed(true) + { + } + bool is_subscribed() {return issubscribed;} + void unsubscribe() {issubscribed = false;} + std::future on_next(T v) { + std::promise ready; + ready.set_value(unit()); + onnext(v); return ready.get_future();} +}; +} +SCENARIO("for loop calls std::future on_next(int)", "[hide][for][asyncobserver][future][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a for loop"){ + WHEN("calling on_next 100 million times"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto c = std::addressof(aliased); + *c = 0; + int n = 1; + auto start = clock::now(); + auto onnext = [&c](int){++*c;}; + asyncwithfuture::async_subscriber scbr(onnext); + for (int i = 0; i < onnextcalls && scbr.is_subscribed(); i++) { + auto isready = scbr.on_next(i); + if (isready.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout) { + isready.wait(); + } + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "loop future : " << n << " subscribed, " << *c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} SCENARIO("for loop calls observer", "[hide][for][observer][perf]"){ const int& onnextcalls = static_onnextcalls; -- GitLab From b88f5992ba41cd2701772d09d7a3d2986d0e0fc4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 1 May 2014 13:05:18 -0700 Subject: [PATCH 269/782] add schedule_periodically perf test --- Rx/v2/test/subjects/subject.cpp | 114 +++++++++++++++++++++++++++++--- 1 file changed, 106 insertions(+), 8 deletions(-) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 21bdf25..045d630 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -88,11 +88,16 @@ SCENARIO("for loop calls void on_next(int)", "[hide][for][asyncobserver][baselin } namespace asyncwithready { +// ready is an immutable class. class ready { public: typedef std::function onthen_type; +private: std::function setthen; +public: + ready() {} + ready(std::function st) : setthen(st) {} bool is_ready() {return !setthen;} void then(onthen_type ot) { if (is_ready()) { @@ -107,15 +112,40 @@ class async_subscriber public: OnNext onnext; bool issubscribed; + int count; explicit async_subscriber(OnNext on) : onnext(on) , issubscribed(true) + , count(0) { } bool is_subscribed() {return issubscribed;} void unsubscribe() {issubscribed = false;} ready on_next(T v) { - onnext(v); return ready();} + // push v onto queue + + // under some condition pop v off of queue and pass it on + onnext(v); + + // for demo purposes + // simulate queue full every 100000 items + if (count == 100000) { + // 'queue is full' + ready no([this](ready::onthen_type ot){ + // full version will sync producer and consumer (in producer push and consumer pop) + // and decide when to restart the producer + if (!this->count) { + ot(); + } + }); + // set queue empty since the demo has no separate consumer thread + count = 0; + // 'queue is empty' + return no; + } + static const ready yes; + return yes; + } }; } SCENARIO("for loop calls ready on_next(int)", "[hide][for][asyncobserver][ready][perf]"){ @@ -131,14 +161,17 @@ SCENARIO("for loop calls ready on_next(int)", "[hide][for][asyncobserver][ready] auto start = clock::now(); auto onnext = [&c](int){++*c;}; asyncwithready::async_subscriber scbr(onnext); - for (int i = 0; i < onnextcalls && scbr.is_subscribed(); i++) { - auto controller = scbr.on_next(i); - if (!controller.is_ready()) { - controller.then([](){ - // todo continue - }); + asyncwithready::ready::onthen_type chunk; + int i = 0; + chunk = [&chunk, scbr, i]() mutable { + for (; i < onnextcalls && scbr.is_subscribed(); i++) { + auto controller = scbr.on_next(i); + if (!controller.is_ready()) { + controller.then(chunk); + } } - } + }; + chunk(); auto finish = clock::now(); auto msElapsed = duration_cast(finish-start); std::cout << "loop ready : " << n << " subscribed, " << *c << " on_next calls, " << msElapsed.count() << "ms elapsed " << std::endl; @@ -403,7 +436,72 @@ SCENARIO("range calls subject", "[hide][range][subject][subjects][perf]"){ } } +SCENARIO("schedule_periodically", "[hide][periodically][scheduler][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("schedule_periodically"){ + WHEN("the period is 1sec and the initial is 2sec"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + auto start = w.now() + seconds(2); + auto period = seconds(1); + w.schedule_periodically(start, period, + [=, &c](rxsc::schedulable scbl){ + auto nsDelta = duration_cast(scbl.now() - (start + (period * c))); + ++c; + std::cout << "schedule_periodically : period " << c << ", " << nsDelta.count() << "ms delta from target time" << std::endl; + if (c == 9) {scbl.unsubscribe();} + }); + } + } +} + +SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("schedule_periodically_duration"){ + WHEN("the period is 1sec and the initial is 2sec"){ + using namespace std::chrono; + typedef steady_clock clock; + int c = 0; + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + + auto schedule_periodically_duration = [w]( + rxsc::current_thread::clock_type::duration initial, + rxsc::current_thread::clock_type::duration period, + rxsc::schedulable activity){ + auto periodic = rxsc::make_schedulable( + activity, + [period, activity](rxsc::schedulable self) { + auto start = clock::now(); + // any recursion requests will be pushed to the scheduler queue + rxsc::recursion r(false); + // call action + activity(r.get_recurse()); + auto finish = clock::now(); + + // schedule next occurance (if the action took longer than 'period' target will be in the past) + self.schedule(period - (finish - start)); + }); + w.schedule(initial, periodic); + }; + + auto start = w.now() + seconds(2); + auto period = seconds(1); + schedule_periodically_duration(seconds(2), period, + rxsc::make_schedulable(w, [=, &c](rxsc::schedulable scbl){ + auto nsDelta = duration_cast(scbl.now() - (start + (period * c))); + ++c; + std::cout << "schedule_periodically_duration : period " << c << ", " << nsDelta.count() << "ms delta from target time" << std::endl; + if (c == 9) {scbl.unsubscribe();} + })); + } + } +} SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ -- GitLab From 26034318f56828e155ffb6493c4e672f56a5ec7c Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 1 May 2014 15:56:00 -0700 Subject: [PATCH 270/782] changes for windows --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 31 +++++++++++++++++-------------- Rx/v2/test/operators/flat_map.cpp | 8 ++++++-- Rx/v2/test/subjects/subject.cpp | 2 +- 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index a59532d..f1e1058 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -332,7 +332,10 @@ public: }; -struct schedulable_base : public subscription_base, public worker_base, public action_base +struct schedulable_base : + // public subscription_base, <- already in worker base + public worker_base, + public action_base { typedef tag_schedulable schedulable_tag; }; @@ -773,7 +776,7 @@ template struct time_schedulable { typedef TimePoint time_point_type; - + time_schedulable(TimePoint when, schedulable a) : when(when) , what(std::move(a)) @@ -783,7 +786,7 @@ struct time_schedulable schedulable what; }; - + // Sorts time_schedulable items in priority order sorted // on value of time_schedulable.when. Items with equal // values for when are sorted in fifo order. @@ -791,10 +794,10 @@ template class schedulable_queue { public: typedef time_schedulable item_type; - typedef std::pair elem_type; + typedef std::pair elem_type; typedef std::vector container_type; typedef const item_type& const_reference; - + private: struct compare_elem { @@ -807,38 +810,38 @@ private: } } }; - + typedef std::priority_queue< elem_type, container_type, compare_elem > queue_type; - + queue_type queue; - - std::int64_t ordinal; + + int64_t ordinal; public: const_reference top() const { return queue.top().first; } - + void pop() { queue.pop(); } - + bool empty() const { return queue.empty(); } - + void push(const item_type& value) { queue.push(elem_type(value, ordinal++)); } - + void push(item_type&& value) { queue.push(elem_type(std::move(value), ordinal++)); } }; - + } } diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index b5b9053..2d5b0f9 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -72,8 +72,12 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ .flat_map( [&c, sc, z](int x){ return rxs::range(x, z, 1, sc) .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) - .map([z, x](int y){return std::make_tuple(x, y, z);});}, - [](int x, std::tuple triplet){return triplet;});}, + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}); triples .take(tripletCount) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 045d630..3b89e95 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -163,7 +163,7 @@ SCENARIO("for loop calls ready on_next(int)", "[hide][for][asyncobserver][ready] asyncwithready::async_subscriber scbr(onnext); asyncwithready::ready::onthen_type chunk; int i = 0; - chunk = [&chunk, scbr, i]() mutable { + chunk = [&chunk, scbr, i, onnextcalls]() mutable { for (; i < onnextcalls && scbr.is_subscribed(); i++) { auto controller = scbr.on_next(i); if (!controller.is_ready()) { -- GitLab From 116de8cc00d2cb09b5e4a5a95b236dcd168e4504 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 1 May 2014 16:30:58 -0700 Subject: [PATCH 271/782] missing return in test --- Rx/v2/test/subjects/subject.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 3b89e95..3a17a36 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -168,6 +168,7 @@ SCENARIO("for loop calls ready on_next(int)", "[hide][for][asyncobserver][ready] auto controller = scbr.on_next(i); if (!controller.is_ready()) { controller.then(chunk); + return; } } }; -- GitLab From 133de119976d14e223c370f688a6db2f9f52932f Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 3 May 2014 23:56:44 -0700 Subject: [PATCH 272/782] add new_thread scheduler --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 7 +- Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 140 ++++++++++++++++++++ 3 files changed, 145 insertions(+), 4 deletions(-) create mode 100644 Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index f1e1058..54cbe8a 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -374,9 +374,9 @@ public: } }; -template -inline scheduler make_scheduler() { - return scheduler(std::static_pointer_cast(std::make_shared())); +template +inline scheduler make_scheduler(ArgN&&... an) { + return scheduler(std::static_pointer_cast(std::make_shared(std::forward(an)...))); } @@ -850,6 +850,7 @@ namespace rxsc=schedulers; } #include "schedulers/rx-currentthread.hpp" +#include "schedulers/rx-newthread.hpp" #include "schedulers/rx-immediate.hpp" #include "schedulers/rx-virtualtime.hpp" diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp index c93a6c3..8209e68 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -20,7 +20,7 @@ private: struct immediate_worker : public worker_interface { private: - typedef immediate this_type; + typedef immediate_worker this_type; immediate_worker(const this_type&); public: virtual ~immediate_worker() diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp new file mode 100644 index 0000000..ddc4444 --- /dev/null +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -0,0 +1,140 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_NEW_THREAD_HPP) +#define RXCPP_RX_SCHEDULER_NEW_THREAD_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +typedef std::function)> thread_factory; + +struct new_thread : public scheduler_interface +{ +private: + typedef new_thread this_type; + new_thread(const this_type&); + + struct new_worker : public worker_interface + { + private: + typedef new_worker this_type; + new_worker(const this_type&); + + typedef detail::schedulable_queue< + typename clock_type::time_point> queue_item_time; + + typedef queue_item_time::item_type item_type; + + composite_subscription lifetime; + mutable std::mutex lock; + mutable std::condition_variable wake; + mutable queue_item_time queue; + std::thread worker; + recursion r; + + public: + virtual ~new_worker() + { + { + std::unique_lock guard(lock); + lifetime.unsubscribe(); + } + worker.join(); + } + new_worker(composite_subscription cs, thread_factory& tf) + : lifetime(cs) + { + lifetime.add(make_subscription([this](){ + wake.notify_one(); + })); + + worker = tf([this](){ + for(;;) { + std::unique_lock guard(lock); + if (queue.empty()) { + wake.wait(guard, [this](){ + return !lifetime.is_subscribed() || !queue.empty(); + }); + } + if (!lifetime.is_subscribed()) { + break; + } + auto& peek = queue.top(); + if (!peek.what.is_subscribed()) { + queue.pop(); + continue; + } + if (clock_type::now() < peek.when) { + wake.wait_until(guard, peek.when); + continue; + } + auto what = peek.what; + queue.pop(); + r.reset(queue.empty()); + guard.unlock(); + what(r.get_recurse()); + } + }); + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual void schedule(const schedulable& scbl) const { + schedule(now(), scbl); + } + + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + if (scbl.is_subscribed()) { + std::unique_lock guard(lock); + queue.push(item_type(when, scbl)); + r.reset(false); + } + wake.notify_one(); + } + }; + + mutable thread_factory factory; + +public: + new_thread() + : factory([](std::function start){ + return std::thread(std::move(start)); + }) + { + } + explicit new_thread(thread_factory tf) + : factory(tf) + { + } + virtual ~new_thread() + { + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual worker create_worker(composite_subscription cs) const { + return worker(cs, std::shared_ptr(new new_worker(cs, factory))); + } +}; + +inline scheduler make_new_thread() { + return make_scheduler(); +} +inline scheduler make_new_thread(thread_factory tf) { + return make_scheduler(tf); +} + +} + +} + +#endif -- GitLab From 10ba193b06f9b7ff306f30c30ce3bbded8ac4780 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 4 May 2014 01:12:48 -0700 Subject: [PATCH 273/782] add event_loop scheduler --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 8 ++ Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp | 110 ++++++++++++++++++++ 2 files changed, 118 insertions(+) create mode 100644 Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 54cbe8a..754a7b0 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -678,6 +678,13 @@ inline auto make_schedulable( return schedulable(std::move(scbl)); } +inline schedulable make_schedulable(worker sc, action a) { + return schedulable(sc, a); +} +inline schedulable make_schedulable(worker sc, composite_subscription cs, action a) { + return schedulable(cs, sc, a); +} + template auto make_schedulable(worker sc, F&& f) -> typename std::enable_if::value, schedulable>::type { @@ -851,6 +858,7 @@ namespace rxsc=schedulers; #include "schedulers/rx-currentthread.hpp" #include "schedulers/rx-newthread.hpp" +#include "schedulers/rx-eventloop.hpp" #include "schedulers/rx-immediate.hpp" #include "schedulers/rx-virtualtime.hpp" diff --git a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp new file mode 100644 index 0000000..fc8deb7 --- /dev/null +++ b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp @@ -0,0 +1,110 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_EVENT_LOOP_HPP) +#define RXCPP_RX_SCHEDULER_EVENT_LOOP_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +struct event_loop : public scheduler_interface +{ +private: + typedef event_loop this_type; + event_loop(const this_type&); + + struct loop_worker : public worker_interface + { + private: + typedef loop_worker this_type; + loop_worker(const this_type&); + + typedef detail::schedulable_queue< + typename clock_type::time_point> queue_item_time; + + typedef queue_item_time::item_type item_type; + + composite_subscription lifetime; + worker controller; + + public: + virtual ~loop_worker() + { + } + loop_worker(composite_subscription cs, worker w) + : lifetime(cs) + , controller(w) + { + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual void schedule(const schedulable& scbl) const { + controller.schedule(lifetime, scbl.get_action()); + } + + virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { + controller.schedule(when, lifetime, scbl.get_action()); + } + }; + + mutable thread_factory factory; + scheduler newthread; + mutable std::atomic count; + std::vector loops; + +public: + event_loop() + : factory([](std::function start){ + return std::thread(std::move(start)); + }) + , newthread(make_new_thread()) + , count(0) + { + auto remaining = std::max(std::thread::hardware_concurrency(), unsigned(4)); + while (--remaining) { + loops.push_back(newthread.create_worker()); + } + } + explicit event_loop(thread_factory tf) + : factory(tf) + , newthread(make_new_thread(tf)) + , count(0) + { + auto remaining = std::max(std::thread::hardware_concurrency(), unsigned(4)); + while (--remaining) { + loops.push_back(newthread.create_worker()); + } + } + virtual ~event_loop() + { + } + + virtual clock_type::time_point now() const { + return clock_type::now(); + } + + virtual worker create_worker(composite_subscription cs) const { + return worker(cs, std::shared_ptr(new loop_worker(cs, loops[++count % loops.size()]))); + } +}; + +inline scheduler make_event_loop() { + static auto loop = make_scheduler(); + return loop; +} +inline scheduler make_event_loop(thread_factory tf) { + return make_scheduler(tf); +} + +} + +} + +#endif -- GitLab From 59d9d055fe64e4f9b56e0ed125b985e319004bb0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 4 May 2014 01:13:29 -0700 Subject: [PATCH 274/782] use static schedulers --- Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp | 3 ++- Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 3 ++- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 3 ++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 1f915f6..6c87bdd 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -243,7 +243,8 @@ public: }; inline scheduler make_current_thread() { - return make_scheduler(); + static auto ct = make_scheduler(); + return ct; } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp index 8209e68..1710fb7 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -73,7 +73,8 @@ public: }; inline scheduler make_immediate() { - return make_scheduler(); + static auto i = make_scheduler(); + return i; } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp index ddc4444..6dcfb9f 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -127,7 +127,8 @@ public: }; inline scheduler make_new_thread() { - return make_scheduler(); + static auto nt = make_scheduler(); + return nt; } inline scheduler make_new_thread(thread_factory tf) { return make_scheduler(tf); -- GitLab From a691721dd4fb201c4b1799ad562bd3ee07adf611 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 8 May 2014 08:18:07 -0700 Subject: [PATCH 275/782] rename connect_now to connect_forever --- ...connect_now.hpp => rx-connect_forever.hpp} | 24 +++++++++---------- Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 10 ++++---- Rx/v2/src/rxcpp/rx-operators.hpp | 2 +- Rx/v2/test/operators/publish.cpp | 6 ++--- 4 files changed, 21 insertions(+), 21 deletions(-) rename Rx/v2/src/rxcpp/operators/{rx-connect_now.hpp => rx-connect_forever.hpp} (56%) diff --git a/Rx/v2/src/rxcpp/operators/rx-connect_now.hpp b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp similarity index 56% rename from Rx/v2/src/rxcpp/operators/rx-connect_now.hpp rename to Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp index ff998f0..35e000f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-connect_now.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp @@ -2,8 +2,8 @@ #pragma once -#if !defined(RXCPP_OPERATORS_RX_CONNECT_NOW_HPP) -#define RXCPP_OPERATORS_RX_CONNECT_NOW_HPP +#if !defined(RXCPP_OPERATORS_RX_CONNECT_FOREVER_HPP) +#define RXCPP_OPERATORS_RX_CONNECT_FOREVER_HPP #include "../rx-includes.hpp" @@ -14,13 +14,13 @@ namespace operators { namespace detail { template -struct connect_now : public operator_base +struct connect_forever : public operator_base { typedef typename std::decay::type source_type; source_type source; - explicit connect_now(source_type o) + explicit connect_forever(source_type o) : source(std::move(o)) { source.connect(); @@ -32,23 +32,23 @@ struct connect_now : public operator_base } }; -class connect_now_factory +class connect_forever_factory { public: - connect_now_factory() {} + connect_forever_factory() {} template auto operator()(Observable&& source) - -> observable::type::value_type, connect_now::type::value_type, Observable>> { - return observable::type::value_type, connect_now::type::value_type, Observable>>( - connect_now::type::value_type, Observable>(std::forward(source))); + -> observable::type::value_type, connect_forever::type::value_type, Observable>> { + return observable::type::value_type, connect_forever::type::value_type, Observable>>( + connect_forever::type::value_type, Observable>(std::forward(source))); } }; } -inline auto connect_now() - -> detail::connect_now_factory { - return detail::connect_now_factory(); +inline auto connect_forever() + -> detail::connect_forever_factory { + return detail::connect_forever_factory(); } } diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index bf63dd0..5fa2d59 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -184,16 +184,16 @@ public: rxo::detail::ref_count(*this)); } - /// connect_now -> + /// connect_forever -> /// takes a connectable_observable source and calls connect during /// the construction of the expression. This means that the source /// starts running without any subscribers and continues running /// after all subscriptions have been unsubscribed. /// - auto connect_now() const - -> observable> { - return observable>( - rxo::detail::connect_now(*this)); + auto connect_forever() const + -> observable> { + return observable>( + rxo::detail::connect_forever(*this)); } }; diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index b0fa902..67bb79f 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -40,7 +40,7 @@ namespace rxo=operators; #include "operators/rx-flat_map.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" -#include "operators/rx-connect_now.hpp" +#include "operators/rx-connect_forever.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 02d799b..729464d 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -35,9 +35,9 @@ SCENARIO("publish range", "[hide][range][subject][publish][operators]"){ // on_completed [](){std::cout << " done." << std::endl;}); } - WHEN("connect_now is used"){ - auto published = rxs::range(0, 10).publish().connect_now(); - std::cout << "subscribe to connect_now" << std::endl; + WHEN("connect_forever is used"){ + auto published = rxs::range(0, 10).publish().connect_forever(); + std::cout << "subscribe to connect_forever" << std::endl; published.subscribe( // on_next [](int v){std::cout << v << ", ";}, -- GitLab From a8404ed7079e2aeeb415129f352d5c8ffe80bef5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 13 May 2014 16:31:39 -0600 Subject: [PATCH 276/782] remove move call --- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index b54deab..b220615 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -45,7 +45,7 @@ struct filter : public operator_base return; } if (!filtered) { - o.on_next(std::move(t)); + o.on_next(t); } }, // on_error -- GitLab From 429aea3ef5fbc0bd6caab7505a44f8a395aaac76 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 13 May 2014 22:40:22 -0600 Subject: [PATCH 277/782] add lift cannot use it easily until C++14 deduced return type for auto functions is available. --- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 76 ++++++ Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 20 ++ Rx/v2/src/rxcpp/rx-observable.hpp | 98 ++++--- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/src/rxcpp/rx-test.hpp | 8 +- Rx/v2/test/operators/lift.cpp | 241 ++++++++++++++++++ projects/CMake/CMakeLists.txt | 3 +- 7 files changed, 412 insertions(+), 35 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-lift.hpp create mode 100644 Rx/v2/test/operators/lift.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp new file mode 100644 index 0000000..ae0a581 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -0,0 +1,76 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_LIFT_HPP) +#define RXCPP_OPERATORS_RX_LIFT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace detail { + +template +struct is_lift_function_for { + + struct tag_not_valid {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)(*(CS*)nullptr)); + template + static tag_not_valid check(...); + + typedef typename std::decay::type for_type; + typedef typename std::decay::type func_type; + typedef decltype(check(0)) detail_result; + static const bool value = is_subscriber::value && is_subscriber::value; +}; + +} + +namespace operators { + +namespace detail { + +template +struct lift_traits +{ + typedef typename std::decay::type source_operator_type; + typedef typename std::decay::type operator_type; + + typedef typename source_operator_type::value_type source_value_type; + + static_assert(rxcpp::detail::is_lift_function_for, operator_type>::value, "lift Operator must be a function with the signature subscriber<...>(subscriber)"); + + typedef decltype((*(operator_type*)nullptr)(*(subscriber*)nullptr)) result_for_dynamic_source_subscriber_type; + + typedef typename result_for_dynamic_source_subscriber_type::value_type result_value_type; +}; + +template +struct lift : public operator_base::result_value_type> +{ + typedef lift_traits traits; + typedef typename traits::source_operator_type source_operator_type; + typedef typename traits::operator_type operator_type; + source_operator_type source; + operator_type chain; + + lift(source_operator_type s, operator_type op) + : source(std::move(s)) + , chain(std::move(op)) + { + } + template + void on_subscribe(const Subscriber& o) const { + source.on_subscribe(chain(o)); + } +}; + +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index 5fa2d59..445e261 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -200,4 +200,24 @@ public: } +// +// support range() >> filter() >> subscribe() syntax +// '>>' is spelled 'stream' +// +template +auto operator >> (const rxcpp::connectable_observable& source, OperatorFactory&& of) + -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { + return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); +} + +// +// support range() | filter() | subscribe() syntax +// '|' is spelled 'pipe' +// +template +auto operator | (const rxcpp::connectable_observable& source, OperatorFactory&& of) + -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { + return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); +} + #endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 26fd032..30a20c3 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -20,8 +20,11 @@ struct is_operator_factory_for template static not_void check(...); - typedef decltype(check::type, typename std::decay::type>(0)) detail_result; - static const bool value = !std::is_same::value; + typedef typename std::decay::type source_type; + typedef typename std::decay::type function_type; + + typedef decltype(check(0)) detail_result; + static const bool value = !std::is_same::value && is_observable::value; }; template @@ -37,6 +40,38 @@ struct has_on_subscribe_for static const bool value = std::is_same::value; }; +struct lift_function { +template +static auto chain(const SourceObservable& source, OperatorFactory&& of) + -> decltype(source.lift(std::forward(of))) { + return source.lift(std::forward(of)); +} +}; +struct operator_factory { +template +static auto chain(const SourceObservable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); +} +}; +struct not_chainable { +}; + +template +struct select_chain +{ + typedef + typename std::conditional< + rxcpp::detail::is_lift_function_for, OperatorFactory>::value, + lift_function, + typename std::conditional< + rxcpp::detail::is_operator_factory_for::value, + operator_factory, + not_chainable + >::type + >::type type; +}; + } template @@ -52,16 +87,6 @@ class dynamic_observable }; std::shared_ptr state; - template - void construct(const dynamic_observable& o, tag_dynamic_observable&&) { - state = o.state; - } - - template - void construct(dynamic_observable&& o, tag_dynamic_observable&&) { - state = std::move(o.state); - } - template void construct(SO&& source, rxs::tag_source&&) { typename std::decay::type so = std::forward(source); @@ -85,11 +110,11 @@ public: } template - explicit dynamic_observable(SOF&& sof) + explicit dynamic_observable(SOF&& sof, typename std::enable_if::value, void**>::type = 0) : state(std::make_shared()) { construct(std::forward(sof), - typename std::conditional::value, tag_dynamic_observable, typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type>::type()); + typename std::conditional::value || rxo::is_operator::value, rxs::tag_source, tag_function>::type()); } void on_subscribe(subscriber o) const { @@ -225,6 +250,31 @@ public: return *this; } + /// + /// takes any function that will take this observable and produce a result value. + /// this is intended to allow externally defined operators, that use subscribe, + /// to be connected into the expression. + /// + template + auto op(OperatorFactory&& of) const + -> decltype(of(*(const this_type*)nullptr)) { + return of(*this); + static_assert(detail::is_operator_factory_for::value, "Function passed for op() must have the signature Result(SourceObservable)"); + } + + /// + /// takes any function that will take a subscriber for this observable and produce a subscriber. + /// this is intended to allow externally defined operators, that use make_subscriber, to be connected + /// into the expression. + /// + template + auto lift(Operator&& op) const + -> observable::value_type, rxo::detail::lift> { + return observable::value_type, rxo::detail::lift>( + rxo::detail::lift(source_operator, std::forward(op))); + static_assert(detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); + } + /// /// subscribe will cause this observable to emit values to the provided subscriber. /// callers must provide enough arguments to make a subscriber. @@ -300,18 +350,6 @@ public: return observable>( rxo::detail::take_until(*this, std::forward(t))); } - - /// - /// takes any function that will take this observable and produce a result value. - /// this is intended to allow externally defined operators to be connected into the expression. - /// - template - auto op(OperatorFactory&& of) const - -> decltype(of(*(const this_type*)nullptr)) { - static_assert(detail::is_operator_factory_for::value, "Function passed for op() must have the signature Result(SourceObservable)"); - return of(*this); - } - }; // observable<> has static methods to construct observable sources and adaptors. @@ -337,8 +375,8 @@ public: // template auto operator >> (const rxcpp::observable& source, OperatorFactory&& of) - -> decltype(source.op(std::forward(of))) { - return source.op(std::forward(of)); + -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { + return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); } // @@ -347,8 +385,8 @@ auto operator >> (const rxcpp::observable& source, OperatorFa // template auto operator | (const rxcpp::observable& source, OperatorFactory&& of) - -> decltype(source.op(std::forward(of))) { - return source.op(std::forward(of)); + -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { + return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); } #endif diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 67bb79f..34c44bf 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -34,6 +34,7 @@ namespace rxo=operators; } +#include "operators/rx-lift.hpp" #include "operators/rx-subscribe.hpp" #include "operators/rx-filter.hpp" #include "operators/rx-map.hpp" diff --git a/Rx/v2/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp index 4038eb7..9edbe44 100644 --- a/Rx/v2/src/rxcpp/rx-test.hpp +++ b/Rx/v2/src/rxcpp/rx-test.hpp @@ -127,8 +127,8 @@ namespace rxt=test; // template auto operator >> (const rxcpp::test::testable_observable& source, OperatorFactory&& of) - -> decltype(source.op(std::forward(of))) { - return source.op(std::forward(of)); + -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { + return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); } // @@ -137,8 +137,8 @@ auto operator >> (const rxcpp::test::testable_observable& source, OperatorFac // template auto operator | (const rxcpp::test::testable_observable& source, OperatorFactory&& of) - -> decltype(source.op(std::forward(of))) { - return source.op(std::forward(of)); + -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { + return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); } #include "schedulers/rx-test.hpp" diff --git a/Rx/v2/test/operators/lift.cpp b/Rx/v2/test/operators/lift.cpp new file mode 100644 index 0000000..2ff144a --- /dev/null +++ b/Rx/v2/test/operators/lift.cpp @@ -0,0 +1,241 @@ + +#define RXCPP_USE_OBSERVABLE_MEMBERS 1 + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +namespace detail { + +template +struct liftfilter +{ + typedef typename std::decay::type test_type; + test_type test; + + liftfilter(test_type t) + : test(t) + { + } + + template + struct filter_observer : public rx::observer_base::type::value_type> + { + typedef filter_observer this_type; + typedef rx::observer_base::type::value_type> base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef rx::observer observer_type; + dest_type dest; + test_type test; + + filter_observer(dest_type d, test_type t) + : dest(d) + , test(t) + { + } + void on_next(typename dest_type::value_type v) const { + bool filtered = false; + try { + filtered = !test(v); + } catch(...) { + dest.on_error(std::current_exception()); + return; + } + if (!filtered) { + dest.on_next(v); + } + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_completed(); + } + + static rx::subscriber make(const dest_type& d, const test_type& t) { + return rx::make_subscriber(d, this_type(d, t)); + } + }; + + template + auto operator()(const Subscriber& dest) const + -> decltype(filter_observer::make(dest, test)) { + return filter_observer::make(dest, test); + } +}; + +} + +namespace { + +template +auto liftfilter(Predicate&& p) + -> detail::liftfilter::type> { + return detail::liftfilter::type>(std::forward(p)); +} + +bool IsPrime(int x) +{ + if (x < 2) return false; + for (int i = 2; i <= x/2; ++i) + { + if (x % i == 0) + return false; + } + return true; +} + +} + +SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + long invoked = 0; + + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600) + }; + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + + WHEN("filtered to ints that are primes"){ + + auto res = w.start( + [&xs, &invoked]() { + return xs + .lift(liftfilter([&invoked](int x) { + invoked++; + return IsPrime(x); + })) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 400 + ); + + THEN("the output only contains primes that arrived before disposal"){ + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + life items[] = { + subscribe(200, 400) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(5 == invoked); + } + } + } +} + +SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + long invoked = 0; + + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600) + }; + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + + WHEN("filtered to ints that are primes"){ + + auto res = w.start( + [&xs, &invoked]() { + return xs + >> liftfilter([&invoked](int x) { + invoked++; + return IsPrime(x); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + >> rxo::as_dynamic(); + }, + 400 + ); + + THEN("the output only contains primes that arrived before disposal"){ + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + life items[] = { + subscribe(200, 400) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(5 == invoked); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 0c75e10..b09e5be 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,13 +42,14 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/operators/lift.cpp + ${V2_TEST_DIR}/operators/filter.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp ${V2_TEST_DIR}/operators/take.cpp ${V2_TEST_DIR}/operators/publish.cpp ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/subscription.cpp ${V2_TEST_DIR}/operators/flat_map.cpp - ${V2_TEST_DIR}/operators/filter.cpp ${V2_TEST_DIR}/operators/map.cpp ) add_executable(rxcppv2_test ${V2_TEST_SOURCES}) -- GitLab From 8623c0df3a01cddb9eb8cfa3d8a54364846ab167 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 15 May 2014 08:22:59 -0600 Subject: [PATCH 278/782] add test for lifting a lambda impl of filter --- Rx/v2/test/operators/lift.cpp | 85 ++++++++++++++++++++++++++++++++++- 1 file changed, 84 insertions(+), 1 deletion(-) diff --git a/Rx/v2/test/operators/lift.cpp b/Rx/v2/test/operators/lift.cpp index 2ff144a..a4c596d 100644 --- a/Rx/v2/test/operators/lift.cpp +++ b/Rx/v2/test/operators/lift.cpp @@ -169,7 +169,7 @@ SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]" } } -SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][operators]"){ +SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][stream][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -239,3 +239,86 @@ SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][oper } } } + +SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + long invoked = 0; + + record messages[] = { + on_next(110, 1), + on_next(180, 2), + on_next(230, 3), + on_next(270, 4), + on_next(340, 5), + on_next(380, 6), + on_next(390, 7), + on_next(450, 8), + on_next(470, 9), + on_next(560, 10), + on_next(580, 11), + on_completed(600) + }; + auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + + WHEN("filtered to ints that are primes"){ + + auto res = w.start( + [&xs, &invoked]() { + auto predicate = [&](int x){ + invoked++; + return IsPrime(x); + }; + return xs + .lift([=](rx::subscriber dest){ + return rx::make_subscriber( + dest, + [=](int n){ + bool pass = false; + try{pass = predicate(n);} catch(...){dest.on_error(std::current_exception());}; + if (pass) {dest.on_next(n);} + }, + [=](std::exception_ptr e){dest.on_error(e);}, + [=](){dest.on_completed();}); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 400 + ); + + THEN("the output only contains primes that arrived before disposal"){ + record items[] = { + on_next(230, 3), + on_next(340, 5), + on_next(390, 7) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + life items[] = { + subscribe(200, 400) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("where was called until disposed"){ + REQUIRE(5 == invoked); + } + } + } +} + -- GitLab From bb2b3a00606e19d88546a4db654dc30111e1da5a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 15 May 2014 08:24:12 -0600 Subject: [PATCH 279/782] changes to the lifetime of subject --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 29 ++++++++++++++----------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index 85412e2..0398c42 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -74,9 +74,10 @@ class multicast_observer struct binder_type : public std::enable_shared_from_this { - binder_type() + explicit binder_type(composite_subscription cs) : state(std::make_shared()) , current_generation(0) + , lifetime(cs) { } @@ -88,6 +89,8 @@ class multicast_observer // must only be accessed under state->lock mutable std::shared_ptr completer; + + composite_subscription lifetime; }; std::shared_ptr b; @@ -95,13 +98,8 @@ class multicast_observer public: - multicast_observer() - : b(std::make_shared()) - { - } - multicast_observer(composite_subscription cs) - : observer_base(std::move(cs)) - , b(std::make_shared()) + explicit multicast_observer(composite_subscription cs) + : b(std::make_shared(cs)) { } bool has_observers() const { @@ -170,6 +168,7 @@ public: } } } + b->lifetime.unsubscribe(); } } void on_completed() const { @@ -185,6 +184,7 @@ public: } } } + b->lifetime.unsubscribe(); } } }; @@ -195,14 +195,13 @@ public: template class subject { + composite_subscription lifetime; detail::multicast_observer s; public: - subject() - { - } - subject(composite_subscription cs) - : s(std::move(cs)) + explicit subject(composite_subscription cs = composite_subscription()) + : lifetime(cs) + , s(cs) { } @@ -211,8 +210,12 @@ public: } subscriber>> get_subscriber(composite_subscription cs = composite_subscription()) const { + auto lt = lifetime; + auto token = lt.add(cs); + cs.add(make_subscription([token, lt](){lt.remove(token);})); return make_subscriber(cs, observer>(s)); } + observable get_observable() const { return make_dynamic_observable([this](subscriber o){ this->s.add(std::move(o)); -- GitLab From f1e239323c3e18b935ba67e8ce15992d23e5107a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 15 May 2014 13:59:34 -0600 Subject: [PATCH 280/782] add publish test --- Rx/v2/test/operators/publish.cpp | 114 ++++++++++++++++++++++++++++++- 1 file changed, 113 insertions(+), 1 deletion(-) diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 729464d..464f7d2 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -47,7 +47,7 @@ SCENARIO("publish range", "[hide][range][subject][publish][operators]"){ } } -SCENARIO("publish", "[publish][multicast][operators]"){ +SCENARIO("publish basic", "[publish][multicast][operators]"){ GIVEN("a test hot observable of longs"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -169,3 +169,115 @@ SCENARIO("publish", "[publish][multicast][operators]"){ } } + +SCENARIO("publish error", "[publish][error][multicast][operators]"){ + GIVEN("a test hot observable of longs"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + long invoked = 0; + + std::runtime_error ex("publish on_error"); + + record messages[] = { + on_next(110, 7), + on_next(220, 3), + on_next(280, 4), + on_next(290, 1), + on_next(340, 8), + on_next(360, 5), + on_next(370, 6), + on_next(390, 7), + on_next(410, 13), + on_next(430, 2), + on_next(450, 9), + on_next(520, 11), + on_next(560, 20), + on_error(600, ex) + }; + auto xs = sc.make_hot_observable(messages); + + auto res = w.make_subscriber(); + + rx::connectable_observable ys; + + WHEN("subscribed and then connected"){ + + w.schedule_absolute(rxsc::test::created_time, + [&invoked, &ys, &xs](const rxsc::schedulable& scbl){ + ys = xs.publish().as_dynamic(); + }); + + w.schedule_absolute(rxsc::test::subscribed_time, + [&ys, &res](const rxsc::schedulable& scbl){ + ys.subscribe(res); + }); + + w.schedule_absolute(rxsc::test::unsubscribed_time, + [&res](const rxsc::schedulable& scbl){ + res.unsubscribe(); + }); + + { + rx::composite_subscription connection; + + w.schedule_absolute(300, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + w.schedule_absolute(400, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + { + rx::composite_subscription connection; + + w.schedule_absolute(500, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + w.schedule_absolute(800, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + w.start(); + + THEN("the output only contains items sent while subscribed"){ + record items[] = { + on_next(340, 8), + on_next(360, 5), + on_next(370, 6), + on_next(390, 7), + on_next(520, 11), + on_next(560, 20), + on_error(600, ex) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there were 3 subscription/unsubscription"){ + life items[] = { + subscribe(300, 400), + subscribe(500, 600) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} -- GitLab From 93a29a50f219e8353e73ff02e55c1256dbbb8a37 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 15 May 2014 23:43:03 -0600 Subject: [PATCH 281/782] move lifetime storage in subject --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index 0398c42..2bbd546 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -36,14 +36,16 @@ class multicast_observer struct state_type : public std::enable_shared_from_this { - state_type() + explicit state_type(composite_subscription cs) : current(mode::Casting) + , lifetime(cs) { } std::atomic generation; std::mutex lock; typename mode::type current; std::exception_ptr error; + composite_subscription lifetime; }; struct completer_type @@ -75,9 +77,8 @@ class multicast_observer : public std::enable_shared_from_this { explicit binder_type(composite_subscription cs) - : state(std::make_shared()) + : state(std::make_shared(cs)) , current_generation(0) - , lifetime(cs) { } @@ -89,8 +90,6 @@ class multicast_observer // must only be accessed under state->lock mutable std::shared_ptr completer; - - composite_subscription lifetime; }; std::shared_ptr b; @@ -159,6 +158,7 @@ public: if (b->state->current == mode::Casting) { b->state->error = e; b->state->current = mode::Errored; + auto s = b->state->lifetime; auto c = std::move(b->completer); guard.unlock(); if (c) { @@ -168,13 +168,14 @@ public: } } } - b->lifetime.unsubscribe(); + s.unsubscribe(); } } void on_completed() const { std::unique_lock guard(b->state->lock); if (b->state->current == mode::Casting) { b->state->current = mode::Completed; + auto s = b->state->lifetime; auto c = std::move(b->completer); guard.unlock(); if (c) { @@ -184,7 +185,7 @@ public: } } } - b->lifetime.unsubscribe(); + s.unsubscribe(); } } }; -- GitLab From 9fffd233c7c4393bd91589aa1ff793a246e1c752 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 15 May 2014 23:44:33 -0600 Subject: [PATCH 282/782] improve dynamic_observer begin improvements based on new understanding of template arg deduction. --- Rx/v2/src/rxcpp/rx-observable.hpp | 21 +--- Rx/v2/src/rxcpp/rx-observer.hpp | 195 ++++++++++++++++-------------- Rx/v2/src/rxcpp/rx-test.hpp | 22 +--- 3 files changed, 110 insertions(+), 128 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 30a20c3..2f04ed9 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -122,24 +122,9 @@ public: } template - typename std::enable_if::type, observer>::value, void>::type - on_subscribe(Subscriber&& o) const { - auto so = std::make_shared::type>(std::forward(o)); - state->on_subscribe(make_subscriber( - *so, - make_observer_dynamic( - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - }))); + typename std::enable_if>::value, void>::type + on_subscribe(Subscriber o) const { + state->on_subscribe(make_subscriber(o, make_observer_dynamic(o.get_observer()))); } }; diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 23b58ab..acdf056 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -71,70 +71,6 @@ struct is_on_completed } -template -class dynamic_observer -{ -public: - typedef tag_dynamic_observer dynamic_observer_tag; - - typedef std::function on_next_t; - typedef std::function on_error_t; - typedef std::function on_completed_t; -private: - typedef observer_base base_type; - - on_next_t onnext; - on_error_t onerror; - on_completed_t oncompleted; - -public: - dynamic_observer() - { - } - - template - dynamic_observer(OnNext&& n, OnError&& e, OnCompleted&& c) - : onnext(std::forward(n)) - , onerror(std::forward(e)) - , oncompleted(std::forward(c)) - { - static_assert(detail::is_on_next_of::value || std::is_same::value, - "Function supplied for on_next must be a function with the signature void(T);"); - static_assert(detail::is_on_error::value || std::is_same::value, - "Function supplied for on_error must be a function with the signature void(std::exception_ptr);"); - static_assert(detail::is_on_completed::value || std::is_same::value, - "Function supplied for on_completed must be a function with the signature void();"); - } - - dynamic_observer& operator=(dynamic_observer o) { - swap(o); - return *this; - } - void swap(dynamic_observer& o) { - using std::swap; - swap(onnext, o.onnext); - swap(onerror, o.onerror); - swap(oncompleted, o.oncompleted); - } - - template - void on_next(V&& v) const { - if (onnext) { - onnext(std::forward(v)); - } - } - void on_error(std::exception_ptr e) const { - if (onerror) { - onerror(e); - } - } - void on_completed() const { - if (oncompleted) { - oncompleted(); - } - } -}; - template class static_observer { @@ -183,9 +119,10 @@ public: swap(oncompleted, o.oncompleted); } + // use V so that std::move can be used safely template - void on_next(V&& v) const { - onnext(std::forward(v)); + void on_next(V v) const { + onnext(std::move(v)); } void on_error(std::exception_ptr e) const { onerror(e); @@ -240,23 +177,103 @@ public: } }; +template +class dynamic_observer +{ +public: + typedef tag_dynamic_observer dynamic_observer_tag; + +private: + typedef observer_base base_type; + + struct virtual_observer : public std::enable_shared_from_this + { + virtual void on_next(T) const =0; + virtual void on_error(std::exception_ptr e) const =0; + virtual void on_completed() const =0; + }; + + template + struct specific_observer : public virtual_observer + { + explicit specific_observer(Observer o) + : destination(std::move(o)) + { + } + + Observer destination; + virtual void on_next(T t) const { + destination.on_next(std::move(t)); + } + virtual void on_error(std::exception_ptr e) const { + destination.on_error(e); + } + virtual void on_completed() const { + destination.on_completed(); + } + }; + + std::shared_ptr destination; + + template + static auto make_destination(Observer o) + -> typename std::enable_if::value, std::shared_ptr>::type { + return std::make_shared>(std::move(o)); + } + +public: + dynamic_observer() + { + } + dynamic_observer(const dynamic_observer& o) + : destination(o.destination) + { + } + dynamic_observer(dynamic_observer&& o) + : destination(std::move(o.destination)) + { + } + + template + explicit dynamic_observer(Observer o) + : destination(make_destination(std::move(o))) + { + } + + dynamic_observer& operator=(dynamic_observer o) { + destination = std::move(o.destination); + return *this; + } + + // perfect forwarding delays the copy of the value. + template + void on_next(V&& v) const { + if (destination) { + destination->on_next(std::forward(v)); + } + } + void on_error(std::exception_ptr e) const { + if (destination) { + destination->on_error(e); + } + } + void on_completed() const { + if (destination) { + destination->on_completed(); + } + } +}; + template auto make_observer() -> observer { return observer(); } -template -auto make_observer(const observer& o) - -> observer { - return observer( - I(o)); -} -template -auto make_observer(observer&& o) +template +auto make_observer(observer o) -> observer { - return observer( - I(std::move(o))); + return observer(std::move(o)); } template auto make_observer(const OnNext& on) @@ -295,17 +312,13 @@ auto make_observer(const OnNext& on, const OnError& oe, const OnCompleted& oc) static_observer(on, oe, oc)); } -template -auto make_observer_dynamic(const observer& o) - -> observer { - return observer( - dynamic_observer(o)); -} -template -auto make_observer_dynamic(observer&& o) - -> observer { - return observer( - dynamic_observer(std::move(o))); + +template +auto make_observer_dynamic(Observer o) + -> typename std::enable_if< + is_observer::value, + observer>::type { + return observer(dynamic_observer(std::move(o))); } template auto make_observer_dynamic(OnNext&& on) @@ -313,7 +326,7 @@ auto make_observer_dynamic(OnNext&& on) detail::is_on_next_of::value, observer>>::type { return observer>( - dynamic_observer(std::forward(on), nullptr, nullptr)); + dynamic_observer(make_observer(std::forward(on)))); } template auto make_observer_dynamic(OnNext&& on, OnError&& oe) @@ -322,7 +335,7 @@ auto make_observer_dynamic(OnNext&& on, OnError&& oe) detail::is_on_error::value, observer>>::type { return observer>( - dynamic_observer(std::forward(on), std::forward(oe), nullptr)); + dynamic_observer(make_observer(std::forward(on), std::forward(oe)))); } template auto make_observer_dynamic(OnNext&& on, OnCompleted&& oc) @@ -331,7 +344,7 @@ auto make_observer_dynamic(OnNext&& on, OnCompleted&& oc) detail::is_on_completed::value, observer>>::type { return observer>( - dynamic_observer(std::forward(on), nullptr, std::forward(oc))); + dynamic_observer(make_observer(std::forward(on), std::forward(oc)))); } template auto make_observer_dynamic(OnNext&& on, OnError&& oe, OnCompleted&& oc) @@ -341,7 +354,7 @@ auto make_observer_dynamic(OnNext&& on, OnError&& oe, OnCompleted&& oc) detail::is_on_completed::value, observer>>::type { return observer>( - dynamic_observer(std::forward(on), std::forward(oe), std::forward(oc))); + dynamic_observer(make_observer(std::forward(on), std::forward(oe), std::forward(oc)))); } } diff --git a/Rx/v2/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp index 9edbe44..cf4841b 100644 --- a/Rx/v2/src/rxcpp/rx-test.hpp +++ b/Rx/v2/src/rxcpp/rx-test.hpp @@ -37,28 +37,12 @@ struct test_source ts->on_subscribe(std::move(o)); } template - typename std::enable_if::type, subscriber>::value, void>::type - on_subscribe(Subscriber&& o) const { + typename std::enable_if>::value, void>::type + on_subscribe(Subscriber o) const { static_assert(is_subscriber::value, "on_subscribe must be passed a subscriber."); - auto so = std::make_shared::type>(std::forward(o)); - ts->on_subscribe( - make_subscriber( - *so, - make_observer_dynamic( - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - }))); + ts->on_subscribe(make_subscriber(o, make_observer_dynamic(o.get_observer()))); } }; -- GitLab From 890cb9bd2736a42f79b9a033665c4ce9d638cf68 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 16 May 2014 00:00:01 -0600 Subject: [PATCH 283/782] observer deduction cleanup --- Rx/v2/src/rxcpp/rx-observer.hpp | 47 ++++++++++++++++++++------------- 1 file changed, 28 insertions(+), 19 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index acdf056..6b573ae 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -108,16 +108,12 @@ public: , oncompleted(std::move(o.oncompleted)) { } - static_observer& operator=(this_type o) { - swap(o); + this_type& operator=(this_type o) { + onnext = std::move(o.onnext); + onerror = std::move(o.onerror); + oncompleted = std::move(o.oncompleted); return *this; } - void swap(this_type& o) { - using std::swap; - swap(onnext, o.onnext); - swap(onerror, o.onerror); - swap(oncompleted, o.oncompleted); - } // use V so that std::move can be used safely template @@ -145,10 +141,22 @@ public: ~observer() { } + observer(const this_type& o) + : inner(o.inner) + { + } + observer(this_type&& o) + : inner(std::move(o.inner)) + { + } explicit observer(inner_t inner) : inner(std::move(inner)) { } + this_type& operator=(this_type o) { + inner = std::move(o.inner); + return *this; + } template void on_next(V&& v) const { inner.on_next(std::forward(v)); @@ -184,6 +192,7 @@ public: typedef tag_dynamic_observer dynamic_observer_tag; private: + typedef dynamic_observer this_type; typedef observer_base base_type; struct virtual_observer : public std::enable_shared_from_this @@ -225,11 +234,11 @@ public: dynamic_observer() { } - dynamic_observer(const dynamic_observer& o) + dynamic_observer(const this_type& o) : destination(o.destination) { } - dynamic_observer(dynamic_observer&& o) + dynamic_observer(this_type&& o) : destination(std::move(o.destination)) { } @@ -240,7 +249,7 @@ public: { } - dynamic_observer& operator=(dynamic_observer o) { + this_type& operator=(this_type o) { destination = std::move(o.destination); return *this; } @@ -276,40 +285,40 @@ auto make_observer(observer o) return observer(std::move(o)); } template -auto make_observer(const OnNext& on) +auto make_observer(OnNext on) -> typename std::enable_if< detail::is_on_next_of::value, observer>>::type { return observer>( - static_observer(on)); + static_observer(std::move(on))); } template -auto make_observer(const OnNext& on, const OnError& oe) +auto make_observer(OnNext on, OnError oe) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_error::value, observer>>::type { return observer>( - static_observer(on, oe)); + static_observer(std::move(on), std::move(oe))); } template -auto make_observer(const OnNext& on, const OnCompleted& oc) +auto make_observer(OnNext on, OnCompleted oc) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_completed::value, observer>>::type { return observer>( - static_observer(on, detail::OnErrorEmpty(), oc)); + static_observer(std::move(on), detail::OnErrorEmpty(), std::move(oc))); } template -auto make_observer(const OnNext& on, const OnError& oe, const OnCompleted& oc) +auto make_observer(OnNext on, OnError oe, OnCompleted oc) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_error::value && detail::is_on_completed::value, observer>>::type { return observer>( - static_observer(on, oe, oc)); + static_observer(std::move(on), std::move(oe), std::move(oc))); } -- GitLab From fb309ecbaa2bef060eb5fe0a9edaeecaddbea8d6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 16 May 2014 13:21:23 -0600 Subject: [PATCH 284/782] subscriber template deduction cleanup --- Rx/v2/src/rxcpp/rx-subscriber.hpp | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 92b672f..7c3207d 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -45,6 +45,19 @@ public: typedef typename composite_subscription::weak_subscription weak_subscription; typedef typename composite_subscription::shared_subscription shared_subscription; + subscriber(const this_type& o) + : lifetime(o.lifetime) + , controller(o.controller) + , destination(o.destination) + { + } + subscriber(this_type&& o) + : lifetime(std::move(o.lifetime)) + , controller(std::move(o.controller)) + , destination(std::move(o.destination)) + { + } + template subscriber(composite_subscription cs, resumption r, U&& o) : lifetime(std::move(cs)) @@ -53,6 +66,13 @@ public: { } + this_type& operator=(this_type o) { + lifetime = std::move(o.lifetime); + controller = std::move(o.controller); + destination = std::move(o.destination); + return *this; + } + const observer_type& get_observer() const { return destination; } @@ -130,17 +150,9 @@ public: }; -// copy -template -auto make_subscriber( - const subscriber& o) - -> subscriber { - return subscriber(o); -} -// move template auto make_subscriber( - subscriber&& o) + subscriber o) -> subscriber { return subscriber(std::move(o)); } -- GitLab From 6349b598029df9c4121e379fc48240c6f61c1d3b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 16 May 2014 13:22:02 -0600 Subject: [PATCH 285/782] add apply and apply_to used to expand tuples to function arguments --- Rx/v2/src/rxcpp/rx-util.hpp | 76 +++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index eb25e67..6b37ca3 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -37,6 +37,82 @@ std::vector to_vector(const T (&arr) [size]) { return std::vector(std::begin(arr), std::end(arr)); } +template +struct values {}; + +template +struct values_from; + +template +struct values_from +{ + typedef values type; +}; + +template +struct values_from +{ + typedef typename values_from::type type; +}; + +namespace detail { + +template +auto apply(std::tuple p, values, F& f) + -> decltype(f(std::forward(std::get(p))...)) { + return f(std::forward(std::get(p))...); +} +template +auto apply(std::tuple p, values, const F& f) + -> decltype(f(std::forward(std::get(p))...)) { + return f(std::forward(std::get(p))...); +} + +} + +template +auto apply(std::tuple p, F& f) + -> decltype(detail::apply(std::move(p), typename values_from::type(), f)) { + return detail::apply(std::move(p), typename values_from::type(), f); +} +template +auto apply(std::tuple p, const F& f) + -> decltype(detail::apply(std::move(p), typename values_from::type(), f)) { + return detail::apply(std::move(p), typename values_from::type(), f); +} + +namespace detail { + +template +struct apply_to +{ + F to; + + explicit apply_to(F f) + : to(std::move(f)) + { + } + + template + auto operator()(std::tuple p) + -> decltype(rxcpp::util::apply(std::move(p), to)) { + return rxcpp::util::apply(std::move(p), to); + } + template + auto operator()(std::tuple p) const + -> decltype(rxcpp::util::apply(std::move(p), to)) { + return rxcpp::util::apply(std::move(p), to); + } +}; + +} + +template +auto apply_to(F f) + -> detail::apply_to { + return detail::apply_to(std::move(f)); +} + namespace detail { template -- GitLab From 1f67a383c47b24ffdf4e97771cebbb89f9c167dd Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 16 May 2014 13:54:52 -0600 Subject: [PATCH 286/782] rename make_dynamic_observable --- Rx/v2/src/rxcpp/rx-observable.hpp | 2 +- Rx/v2/src/rxcpp/rx-predef.hpp | 2 +- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 2f04ed9..016bba3 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -129,7 +129,7 @@ public: }; template -observable make_dynamic_observable(Source&& s) { +observable make_observable_dynamic(Source&& s) { return observable(dynamic_observable(std::forward(s))); } diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 25a75c8..688c8ea 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -129,7 +129,7 @@ template< class observable; template -observable make_dynamic_observable(Source&&); +observable make_observable_dynamic(Source&&); struct tag_observable {}; template diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index 2bbd546..dffa37c 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -218,7 +218,7 @@ public: } observable get_observable() const { - return make_dynamic_observable([this](subscriber o){ + return make_observable_dynamic([this](subscriber o){ this->s.add(std::move(o)); }); } -- GitLab From fba0f2d04f8d6ac53994a994353f6ae3cb6a2219 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 20 May 2014 08:35:26 -0700 Subject: [PATCH 287/782] add synchronize subject and fix lifetime issues This finally forced a rewrite of subscription. pretty happy with the result. flat map removed all sync and takes a new parameter that is applied to every source and can be used to synchronize them also added multicast --- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 92 ++-- Rx/v2/src/rxcpp/operators/rx-multicast.hpp | 97 +++++ Rx/v2/src/rxcpp/operators/rx-publish.hpp | 45 +- Rx/v2/src/rxcpp/operators/rx-ref_count.hpp | 4 +- Rx/v2/src/rxcpp/rx-includes.hpp | 2 + Rx/v2/src/rxcpp/rx-notification.hpp | 22 +- Rx/v2/src/rxcpp/rx-observable.hpp | 62 ++- Rx/v2/src/rxcpp/rx-observer.hpp | 25 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/src/rxcpp/rx-scheduler.hpp | 15 +- Rx/v2/src/rxcpp/rx-subjects.hpp | 3 +- Rx/v2/src/rxcpp/rx-subscriber.hpp | 9 +- Rx/v2/src/rxcpp/rx-subscription.hpp | 442 ++++++++++++-------- Rx/v2/src/rxcpp/rx-util.hpp | 4 +- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 8 +- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 17 +- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 214 ++++++++++ Rx/v2/test/operators/flat_map.cpp | 85 +++- Rx/v2/test/subscriptions/observer.cpp | 4 - Rx/v2/test/subscriptions/subscription.cpp | 47 +-- 20 files changed, 838 insertions(+), 360 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-multicast.hpp create mode 100644 Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 38dd15f..96e7ea6 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -13,11 +13,12 @@ namespace operators { namespace detail { -template +template struct flat_map_traits { typedef typename std::decay::type source_type; typedef typename std::decay::type collection_selector_type; typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type source_filter_type; typedef typename source_type::value_type source_value_type; @@ -47,12 +48,12 @@ struct flat_map_traits { typedef decltype((*(result_selector_type*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; }; -template +template struct flat_map - : public operator_base::value_type> + : public operator_base::value_type> { - typedef flat_map this_type; - typedef flat_map_traits traits; + typedef flat_map this_type; + typedef flat_map_traits traits; typedef typename traits::source_type source_type; typedef typename traits::collection_selector_type collection_selector_type; @@ -62,22 +63,26 @@ struct flat_map typedef typename traits::collection_type collection_type; typedef typename traits::collection_value_type collection_value_type; + typedef typename traits::source_filter_type source_filter_type; + struct values { - values(source_type o, collection_selector_type s, result_selector_type rs) + values(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) : source(std::move(o)) , selectCollection(std::move(s)) , selectResult(std::move(rs)) + , sourceFilter(std::move(sf)) { } source_type source; collection_selector_type selectCollection; result_selector_type selectResult; + source_filter_type sourceFilter; }; values initial; - flat_map(source_type o, collection_selector_type s, result_selector_type rs) - : initial(std::move(o), std::move(s), std::move(rs)) + flat_map(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + : initial(std::move(o), std::move(s), std::move(rs), std::move(sf)) { } @@ -99,12 +104,7 @@ struct flat_map } // on_completed on the output must wait until all the // subscriptions have received on_completed - std::atomic pendingCompletions; - // because multiple sources are subscribed to by flat_map, - // calls to the output must be serialized by lock. - // the on_error/on_complete and unsubscribe calls can - // cause lock recursion. - std::recursive_mutex lock; + int pendingCompletions; output_type out; }; // take a copy of the values for each subscription @@ -116,21 +116,26 @@ struct flat_map // inner subscriptions are unsubscribed as well state->out.add(outercs); + auto source = on_exception( + [&](){return state->sourceFilter(state->source);}, + state->out); + if (source.empty()) { + return; + } + ++state->pendingCompletions; // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - state->source.subscribe( + source->subscribe( state->out, outercs, // on_next [state](source_value_type st) { - util::detail::maybe selectedCollection; - try { - selectedCollection.reset(state->selectCollection(st)); - } catch(...) { - std::unique_lock guard(state->lock); - state->out.on_error(std::current_exception()); + auto selectedCollection = on_exception( + [&](){return state->selectCollection(st);}, + state->out); + if (selectedCollection.empty()) { return; } @@ -144,34 +149,36 @@ struct flat_map state->out.remove(innercstoken); })); + auto selectedSource = on_exception( + [&](){return state->sourceFilter(selectedCollection.get());}, + state->out); + if (selectedSource.empty()) { + return; + } + ++state->pendingCompletions; // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue - selectedCollection->subscribe( + selectedSource->subscribe( state->out, innercs, // on_next [state, st](collection_value_type ct) { - util::detail::maybe selectedResult; - try { - selectedResult.reset(state->selectResult(st, std::move(ct))); - } catch(...) { - std::unique_lock guard(state->lock); - state->out.on_error(std::current_exception()); + auto selectedResult = on_exception( + [&](){return state->selectResult(st, std::move(ct));}, + state->out); + if (selectedResult.empty()) { return; } - std::unique_lock guard(state->lock); state->out.on_next(std::move(*selectedResult)); }, // on_error [state](std::exception_ptr e) { - std::unique_lock guard(state->lock); state->out.on_error(e); }, //on_completed [state](){ if (--state->pendingCompletions == 0) { - std::unique_lock guard(state->lock); state->out.on_completed(); } } @@ -179,13 +186,11 @@ struct flat_map }, // on_error [state](std::exception_ptr e) { - std::unique_lock guard(state->lock); state->out.on_error(e); }, // on_completed [state]() { if (--state->pendingCompletions == 0) { - std::unique_lock guard(state->lock); state->out.on_completed(); } } @@ -193,35 +198,38 @@ struct flat_map } }; -template +template class flat_map_factory { typedef typename std::decay::type collection_selector_type; typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type source_filter_type; collection_selector_type selectorCollection; result_selector_type selectorResult; + source_filter_type sourceFilter; public: - flat_map_factory(collection_selector_type s, result_selector_type rs) + flat_map_factory(collection_selector_type s, result_selector_type rs, source_filter_type sf) : selectorCollection(std::move(rs)) , selectorResult(std::move(s)) + , sourceFilter(std::move(sf)) { } template auto operator()(Observable&& source) - -> observable::value_type, flat_map> { - return observable::value_type, flat_map>( - flat_map(std::forward(source), std::move(selectorCollection), std::move(selectorResult))); + -> observable::value_type, flat_map> { + return observable::value_type, flat_map>( + flat_map(std::forward(source), std::move(selectorCollection), std::move(selectorResult), std::move(sourceFilter))); } }; } -template -auto flat_map(CollectionSelector&& s, ResultSelector&& rs) - -> detail::flat_map_factory { - return detail::flat_map_factory(std::forward(s), std::forward(rs)); +template +auto flat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) + -> detail::flat_map_factory { + return detail::flat_map_factory(std::forward(s), std::forward(rs), std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp new file mode 100644 index 0000000..7f25071 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp @@ -0,0 +1,97 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_MULTICAST_HPP) +#define RXCPP_OPERATORS_RX_MULTICAST_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct multicast : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type subject_type; + + struct multicast_state : public std::enable_shared_from_this + { + multicast_state(source_type o, subject_type sub) + : source(std::move(o)) + , subject_value(std::move(sub)) + { + } + source_type source; + subject_type subject_value; + rxu::detail::maybe connection; + }; + + std::shared_ptr state; + + multicast(source_type o, subject_type sub) + : state(std::make_shared(std::move(o), std::move(sub))) + { + } + template + void on_subscribe(Subscriber&& o) { + state->subject_value.get_observable().subscribe(std::forward(o)); + } + void on_connect(composite_subscription cs) { + if (state->connection.empty()) { + auto destination = state->subject_value.get_subscriber(); + + // the lifetime of each connect is nested in the subject lifetime + state->connection.reset(destination.add(cs)); + + auto localState = state; + + // when the connection is finished it should shutdown the connection + cs.add( + [destination, localState](){ + if (!localState->connection.empty()) { + destination.remove(localState->connection.get()); + localState->connection.reset(); + } + }); + + // use cs not destination for lifetime of subscribe. + state->source.subscribe(cs, destination); + } + } +}; + +template +class multicast_factory +{ + Subject caster; +public: + multicast_factory(Subject sub) + : caster(std::move(sub)) + { + } + template + auto operator()(Observable&& source) + -> connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject>> { + return connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject>>( + multicast::type::value_type, Observable, Subject>(std::forward(source), caster)); + } +}; + +} + +template +inline auto multicast(Subject sub) + -> detail::multicast_factory { + return detail::multicast_factory(std::move(sub)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/operators/rx-publish.hpp b/Rx/v2/src/rxcpp/operators/rx-publish.hpp index fcb89f3..34de51a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-publish.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-publish.hpp @@ -13,44 +13,6 @@ namespace operators { namespace detail { -template -struct publish : public operator_base -{ - typedef typename std::decay::type source_type; - typedef typename std::decay::type subject_type; - source_type source; - subject_type subject_value; - rxu::detail::maybe connection; - - explicit publish(source_type o) - : source(std::move(o)) - { - } - template - void on_subscribe(Subscriber&& o) { - subject_value.get_observable().subscribe(std::forward(o)); - } - void on_connect(composite_subscription cs) { - if (connection.empty()) { - // the lifetime of each connect is independent - auto destination = subject_value.get_subscriber(); - - // when the paramter is unsubscribed it should - // unsubscribe the most recent connection - connection.reset(cs.add(destination.get_subscription())); - - // when the connection is finished it should shutdown the connection - destination.add(make_subscription( - [cs, this](){ - cs.remove(this->connection.get()); - this->connection.reset(); - })); - - source.subscribe(destination); - } - } -}; - template class Subject> class publish_factory { @@ -58,9 +20,10 @@ public: publish_factory() {} template auto operator()(Observable&& source) - -> connectable_observable::type::value_type, publish::type::value_type, Observable, Subject::type::value_type>>> { - return connectable_observable::type::value_type, publish::type::value_type, Observable, Subject::type::value_type>>>( - publish::type::value_type, Observable, Subject::type::value_type>>(std::forward(source))); + -> connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject::type::value_type>>> { + return connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject::type::value_type>>>( + multicast::type::value_type, Observable, Subject::type::value_type>>( + std::forward(source), Subject::type::value_type>())); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp index 8d8b1a7..52a3d30 100644 --- a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -31,12 +31,12 @@ struct ref_count : public operator_base template void on_subscribe(Subscriber&& o) { auto needConnect = ++subscribers == 1; - o.add(make_subscription( + o.add( [this](){ if (--this->subscribers == 0) { this->connection.unsubscribe(); } - })); + }); source.subscribe(std::forward(o)); if (needConnect) { connection = source.connect(); diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index b15a3d1..75518ab 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -85,6 +85,7 @@ #include #include #include +#include #include #include #include @@ -94,6 +95,7 @@ #include #include #include +#include #include "rx-util.hpp" #include "rx-predef.hpp" diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index dd1ff78..8e4d27a 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -56,6 +56,24 @@ struct notification_base virtual void accept(const observer_type& o) const =0; }; +template +auto to_stream(std::ostream& os, const T& t, int, int) + -> decltype(os << t) { + return os << t; +} + +template +auto to_stream(std::ostream& os, const T&, int, ...) + -> decltype(os << typeid(T).name() << "") { + return os << "< " << typeid(T).name() << " does not support ostream>"; +} + +template +auto to_stream(std::ostream& os, const T&, ...) + -> decltype(os << "") { + return os << ""; +} + } template @@ -71,7 +89,9 @@ private: on_next_notification(T value) : value(std::move(value)) { } virtual void out(std::ostream& os) const { - os << "on_next( " << value << ")"; + os << "on_next( "; + detail::to_stream(os, value, 0, 0); + os << ")"; } virtual bool equals(const typename base::type& other) const { bool result = false; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 016bba3..5c197a3 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -74,6 +74,20 @@ struct select_chain } +// +// this type is the default used by operators that subscribe to +// multiple sources. It assumes that the sources are already synchronized +// +struct identity_observable +{ + template + auto operator()(Observable o) + -> Observable { + return std::move(o); + static_assert(is_observable::value, "only support observables"); + } +}; + template class dynamic_observable : public rxs::source_base @@ -150,7 +164,7 @@ private: template auto detail_subscribe(Subscriber&& scrbr) const - -> decltype(make_subscription(*(typename std::decay::type*)nullptr)) { + -> composite_subscription { typedef typename std::decay::type subscriber_type; subscriber_type o = std::forward(scrbr); @@ -160,7 +174,7 @@ private: static_assert(detail::has_on_subscribe_for::value, "inner must have on_subscribe method that accepts this subscriber "); if (!o.is_subscribed()) { - return make_subscription(o); + return o.get_subscription(); } auto safe_subscribe = [=]() { @@ -189,7 +203,7 @@ private: safe_subscribe(); } - return make_subscription(o); + return o.get_subscription(); } public: @@ -302,18 +316,46 @@ public: /// template auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::flat_map> { - return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs))); + -> observable::value_type, rxo::detail::flat_map> { + return observable::value_type, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_observable())); + } + + /// flat_map (AKA SelectMany) -> + /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. + /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. + /// + template + auto flat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) const + -> observable::value_type, rxo::detail::flat_map> { + return observable::value_type, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); + } + + /// multicast -> + /// allows connections to the source to be independent of subscriptions + /// + template + auto multicast(Subject sub) const + -> connectable_observable> { + return connectable_observable>( + rxo::detail::multicast(*this, std::move(sub))); + } + + /// synchronize -> + /// turns a cold observable hot and allows connections to the source to be independent of subscriptions + /// + auto synchronize(rxsc::worker w, composite_subscription cs = composite_subscription()) const + -> decltype(multicast(rxsub::synchronize(w, cs))) { + return multicast(rxsub::synchronize(w, cs)); } /// publish -> /// turns a cold observable hot and allows connections to the source to be independent of subscriptions /// - auto publish() const - -> connectable_observable>> { - return connectable_observable>>( - rxo::detail::publish>(*this)); + auto publish(composite_subscription cs = composite_subscription()) const + -> decltype(multicast(rxsub::subject(cs))) { + return multicast(rxsub::subject(cs)); } /// take -> diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 6b573ae..b6bad50 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -366,6 +366,31 @@ auto make_observer_dynamic(OnNext&& on, OnError&& oe, OnCompleted&& oc) dynamic_observer(make_observer(std::forward(on), std::forward(oe), std::forward(oc)))); } + +template +auto on_exception(const F& f, const OnError& c) + -> typename std::enable_if::value, rxu::detail::maybe>::type { + rxu::detail::maybe r; + try { + r.reset(f()); + } catch (...) { + c(std::current_exception()); + } + return r; +} + +template +auto on_exception(const F& f, const Subscriber& s) + -> typename std::enable_if::value, rxu::detail::maybe>::type { + rxu::detail::maybe r; + try { + r.reset(f()); + } catch (...) { + s.on_error(std::current_exception()); + } + return r; +} + } #endif diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 34c44bf..48c84d5 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -39,6 +39,7 @@ namespace rxo=operators; #include "operators/rx-filter.hpp" #include "operators/rx-map.hpp" #include "operators/rx-flat_map.hpp" +#include "operators/rx-multicast.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" #include "operators/rx-connect_forever.hpp" diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 754a7b0..5713b58 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -193,7 +193,6 @@ class worker : public worker_base friend bool operator==(const worker&, const worker&); public: typedef scheduler_base::clock_type clock_type; - typedef composite_subscription::shared_subscription shared_subscription; typedef composite_subscription::weak_subscription weak_subscription; worker() @@ -217,10 +216,7 @@ public: inline bool is_subscribed() const { return lifetime.is_subscribed(); } - inline weak_subscription add(shared_subscription s) const { - return lifetime.add(std::move(s)); - } - inline weak_subscription add(dynamic_subscription s) const { + inline weak_subscription add(subscription s) const { return lifetime.add(std::move(s)); } inline void remove(weak_subscription w) const { @@ -452,7 +448,6 @@ class schedulable : public schedulable_base public: typedef composite_subscription::weak_subscription weak_subscription; - typedef composite_subscription::shared_subscription shared_subscription; typedef scheduler_base::clock_type clock_type; ~schedulable() @@ -543,11 +538,13 @@ public: inline bool is_subscribed() const { return lifetime.is_subscribed(); } - inline weak_subscription add(shared_subscription s) const { + inline weak_subscription add(subscription s) const { return lifetime.add(std::move(s)); } - inline weak_subscription add(dynamic_subscription s) const { - return lifetime.add(std::move(s)); + template + auto add(F f) const + -> typename std::enable_if::value, weak_subscription>::type { + return lifetime.add(make_subscription(std::move(f))); } inline void remove(weak_subscription w) const { return lifetime.remove(std::move(w)); diff --git a/Rx/v2/src/rxcpp/rx-subjects.hpp b/Rx/v2/src/rxcpp/rx-subjects.hpp index 1289835..3c3fb32 100644 --- a/Rx/v2/src/rxcpp/rx-subjects.hpp +++ b/Rx/v2/src/rxcpp/rx-subjects.hpp @@ -17,5 +17,6 @@ namespace rxsub=subjects; } #include "subjects/rx-subject.hpp" +#include "subjects/rx-synchronize.hpp" -#endif \ No newline at end of file +#endif diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 7c3207d..939d76c 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -43,7 +43,6 @@ class subscriber : public subscriber_base subscriber(); public: typedef typename composite_subscription::weak_subscription weak_subscription; - typedef typename composite_subscription::shared_subscription shared_subscription; subscriber(const this_type& o) : lifetime(o.lifetime) @@ -132,11 +131,13 @@ public: bool is_subscribed() const { return lifetime.is_subscribed(); } - weak_subscription add(shared_subscription s) const { + weak_subscription add(subscription s) const { return lifetime.add(std::move(s)); } - weak_subscription add(dynamic_subscription s) const { - return lifetime.add(std::move(s)); + template + auto add(F f) const + -> typename std::enable_if::value, weak_subscription>::type { + return lifetime.add(make_subscription(std::move(f))); } void remove(weak_subscription w) const { return lifetime.remove(std::move(w)); diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 40700e8..527d52b 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -9,6 +9,21 @@ namespace rxcpp { +namespace detail { + +template +struct is_unsubscribe_function +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)()); + template + static not_void check(...); + + static const bool value = std::is_same::type>(0)), void>::value; +}; + +} struct tag_subscription {}; struct subscription_base {typedef tag_subscription subscription_tag;}; @@ -23,39 +38,8 @@ public: static const bool value = std::is_convertible::type>(0)), tag_subscription*>::value; }; -class dynamic_subscription : public subscription_base -{ - typedef std::function unsubscribe_call_type; - unsubscribe_call_type unsubscribe_call; - dynamic_subscription() - { - } -public: - dynamic_subscription(const dynamic_subscription& o) - : unsubscribe_call(o.unsubscribe_call) - { - } - dynamic_subscription(dynamic_subscription&& o) - : unsubscribe_call(std::move(o.unsubscribe_call)) - { - } - template - dynamic_subscription(I i, typename std::enable_if::value && !std::is_same::value, void**>::type selector = nullptr) - : unsubscribe_call([i](){ - i.unsubscribe();}) - { - } - dynamic_subscription(unsubscribe_call_type s) - : unsubscribe_call(std::move(s)) - { - } - void unsubscribe() const { - unsubscribe_call(); - } -}; - template -class static_subscription : public subscription_base +class static_subscription { typedef typename std::decay::type unsubscribe_call_type; unsubscribe_call_type unsubscribe_call; @@ -80,178 +64,243 @@ public: } }; -template class subscription : public subscription_base { - typedef typename std::decay::type inner_t; - inner_t inner; - mutable bool issubscribed; + class base_subscription_state : public std::enable_shared_from_this + { + base_subscription_state(); + public: + + explicit base_subscription_state(bool initial) + : issubscribed(initial) + { + } + virtual void unsubscribe() { + issubscribed = false; + } + std::atomic issubscribed; + }; public: - subscription(inner_t inner) - : inner(std::move(inner)) - , issubscribed(true) + typedef std::weak_ptr weak_state_type; + +private: + template + struct subscription_state : public base_subscription_state { - } - bool is_subscribed() const { - return issubscribed; - } - void unsubscribe() const { - if (issubscribed) { - inner.unsubscribe(); + typedef typename std::decay::type inner_t; + subscription_state(inner_t i) + : base_subscription_state(true) + , inner(std::move(i)) + { + } + virtual void unsubscribe() { + if (issubscribed.exchange(false)) { + inner.unsubscribe(); + } + } + inner_t inner; + }; + std::shared_ptr state; + + friend bool operator<(const subscription&, const subscription&); + friend bool operator==(const subscription&, const subscription&); + + subscription(weak_state_type w) + : state(w.lock()) + { + if (!state) { + abort(); } - issubscribed = false; } -}; -template<> -class subscription : public subscription_base -{ public: + subscription() + : state(std::make_shared(false)) + { + if (!state) { + abort(); + } + } + template + explicit subscription(U u, typename std::enable_if::value, void**>::type = nullptr) + : state(std::make_shared>(std::move(u))) + { + if (!state) { + abort(); + } + } + template + explicit subscription(U u, typename std::enable_if::value && is_subscription::value, void**>::type = nullptr) + // intentionally slice + : state(std::move(static_cast(u).state)) + { + if (!state) { + abort(); + } + } + subscription(const subscription& o) + : state(o.state) + { + if (!state) { + abort(); + } + } + subscription(subscription&& o) + : state(std::move(o.state)) { + if (!state) { + abort(); + } + } + subscription& operator=(subscription o) { + state = std::move(o.state); + return *this; } bool is_subscribed() const { - return false; + if (!state) { + abort(); + } + return state->issubscribed; } void unsubscribe() const { + if (!state) { + abort(); + } + auto keepAlive = state; + state->unsubscribe(); + } + + weak_state_type get_weak() { + return state; + } + static subscription lock(weak_state_type w) { + return subscription(w); } }; + +inline bool operator<(const subscription& lhs, const subscription& rhs) { + return lhs.state < rhs.state; +} +inline bool operator==(const subscription& lhs, const subscription& rhs) { + return lhs.state == rhs.state; +} +inline bool operator!=(const subscription& lhs, const subscription& rhs) { + return !(lhs == rhs); +} + + inline auto make_subscription() - -> subscription { - return subscription(); + -> subscription { + return subscription(); } template auto make_subscription(I&& i) - -> typename std::enable_if::value, - subscription>::type { - return subscription(std::forward(i)); + -> typename std::enable_if::value && !detail::is_unsubscribe_function::value, + subscription>::type { + return subscription(std::forward(i)); } template auto make_subscription(Unsubscribe&& u) - -> typename std::enable_if::value, - subscription< static_subscription>>::type { - return subscription< static_subscription>( - static_subscription(std::forward(u))); + -> typename std::enable_if::value, + subscription>::type { + return subscription(static_subscription(std::forward(u))); } -class composite_subscription : public subscription_base +namespace detail { + +struct tag_composite_subscription_empty {}; + +class composite_subscription_inner { -public: - typedef std::shared_ptr shared_subscription; - typedef std::weak_ptr weak_subscription; private: - struct tag_empty {}; - struct state_t : public std::enable_shared_from_this + typedef subscription::weak_state_type weak_subscription; + struct composite_subscription_state : public std::enable_shared_from_this { - std::vector subscriptions; - std::recursive_mutex lock; - bool issubscribed; + std::set subscriptions; + std::mutex lock; + std::atomic issubscribed; - state_t() - : issubscribed(true) + ~composite_subscription_state() { + std::unique_lock guard(lock); + subscriptions.clear(); } - state_t(tag_empty&&) - : issubscribed(false) + composite_subscription_state() + : issubscribed(true) { } - - inline bool is_subscribed() { - return issubscribed; - } - - inline weak_subscription add(dynamic_subscription s) { - return add(std::make_shared(std::move(s))); + composite_subscription_state(tag_composite_subscription_empty) + : issubscribed(false) + { } - inline weak_subscription add(shared_subscription s) { - std::unique_lock guard(lock); - + inline weak_subscription add(subscription s) { if (!issubscribed) { - s->unsubscribe(); - } else { - auto end = std::end(subscriptions); - auto it = std::find(std::begin(subscriptions), end, s); - if (it == end) - { - subscriptions.emplace_back(s); - } + s.unsubscribe(); + } else if (s.is_subscribed()) { + std::unique_lock guard(lock); + subscriptions.insert(s); } - return s; + return s.get_weak(); } inline void remove(weak_subscription w) { - std::unique_lock guard(lock); - if (issubscribed && !w.expired()) { - auto s = w.lock(); - if (s) - { - auto end = std::end(subscriptions); - auto it = std::find(std::begin(subscriptions), end, s); - if (it != end) - { - subscriptions.erase(it); - } - } + std::unique_lock guard(lock); + subscriptions.erase(subscription::lock(w)); } } inline void clear() { - std::unique_lock guard(lock); - if (issubscribed) { - std::vector v(std::move(subscriptions)); + std::unique_lock guard(lock); + + std::set v(std::move(subscriptions)); + guard.unlock(); std::for_each(v.begin(), v.end(), - [](shared_subscription& s) { - s->unsubscribe(); }); + [](const subscription& s) { + s.unsubscribe(); }); } } inline void unsubscribe() { - std::unique_lock guard(lock); + if (issubscribed.exchange(false)) { + std::unique_lock guard(lock); - if (issubscribed) { - issubscribed = false; - std::vector v(std::move(subscriptions)); + std::set v(std::move(subscriptions)); + guard.unlock(); std::for_each(v.begin(), v.end(), - [](shared_subscription& s) { - s->unsubscribe(); }); + [](const subscription& s) { + s.unsubscribe(); }); } } }; - mutable std::shared_ptr state; +public: + typedef std::shared_ptr shared_state_type; - static std::shared_ptr shared_empty; +protected: + mutable shared_state_type state; - composite_subscription(std::shared_ptr s) - : state(std::move(s)) +public: + composite_subscription_inner() + : state(std::make_shared()) { - if (!state) { - abort(); - } } - - friend bool operator==(const composite_subscription&, const composite_subscription&); - -public: - - composite_subscription() - : state(std::make_shared()) + composite_subscription_inner(tag_composite_subscription_empty et) + : state(std::make_shared(et)) { - if (!state) { - abort(); - } } - composite_subscription(const composite_subscription& o) + + composite_subscription_inner(const composite_subscription_inner& o) : state(o.state) { if (!state) { abort(); } } - composite_subscription(composite_subscription&& o) + composite_subscription_inner(composite_subscription_inner&& o) : state(std::move(o.state)) { if (!state) { @@ -259,75 +308,120 @@ public: } } - composite_subscription& operator=(const composite_subscription& o) + composite_subscription_inner& operator=(composite_subscription_inner o) { - state = o.state; + state = std::move(o.state); if (!state) { abort(); } return *this; } - composite_subscription& operator=(composite_subscription&& o) - { - state = std::move(o.state); + + inline weak_subscription add(subscription s) const { if (!state) { abort(); } - return *this; - } - - static inline composite_subscription empty() { - return composite_subscription(shared_empty); - } - - inline bool is_subscribed() const { - return state->is_subscribed(); - } - inline weak_subscription add(shared_subscription s) const { - return state->add(std::move(s)); - } - inline weak_subscription add(dynamic_subscription s) const { + if (s == static_cast(*this)) { + // do not nest the same subscription + abort(); + //return s.get_weak(); + } return state->add(std::move(s)); } inline void remove(weak_subscription w) const { + if (!state) { + abort(); + } state->remove(std::move(w)); } inline void clear() const { + if (!state) { + abort(); + } state->clear(); } - inline void unsubscribe() const { + inline void unsubscribe() { + if (!state) { + abort(); + } state->unsubscribe(); } }; -inline bool operator==(const composite_subscription& lhs, const composite_subscription& rhs) { - return lhs.state == rhs.state; -} -inline bool operator!=(const composite_subscription& lhs, const composite_subscription& rhs) { - return !(lhs == rhs); } -//static -RXCPP_SELECT_ANY std::shared_ptr composite_subscription::shared_empty = std::make_shared(composite_subscription::tag_empty()); +class composite_subscription + : protected detail::composite_subscription_inner + , public subscription +{ + typedef detail::composite_subscription_inner inner_type; +public: + typedef subscription::weak_state_type weak_subscription; + static composite_subscription shared_empty; -namespace detail { + composite_subscription(detail::tag_composite_subscription_empty et) + : inner_type(et) + , subscription() // use empty base + { + } -struct tag_subscription_resolution -{ - template - struct predicate +public: + + composite_subscription() + : inner_type() + , subscription(static_cast(*this)) { - static const bool value = !is_subscriber::value && !is_observer::value && is_subscription::value; - }; - struct default_type { - inline operator composite_subscription() const { - return composite_subscription(); - } - }; + } + + composite_subscription(const composite_subscription& o) + : inner_type(o) + , subscription(static_cast(o)) + { + } + composite_subscription(composite_subscription&& o) + : inner_type(std::move(o)) + , subscription(std::move(static_cast(o))) + { + } + + composite_subscription& operator=(composite_subscription o) + { + inner_type::operator=(std::move(o)); + subscription::operator=(std::move(static_cast(o))); + return *this; + } + + static inline composite_subscription empty() { + return shared_empty; + } + + using subscription::is_subscribed; + using subscription::unsubscribe; + + using inner_type::add; + using inner_type::remove; + using inner_type::clear; + + template + auto add(F f) const + -> typename std::enable_if::value, weak_subscription>::type { + return inner_type::add(make_subscription(std::move(f))); + } }; +inline bool operator<(const composite_subscription& lhs, const composite_subscription& rhs) { + return static_cast(lhs) < static_cast(rhs); } +inline bool operator==(const composite_subscription& lhs, const composite_subscription& rhs) { + return static_cast(lhs) == static_cast(rhs); +} +inline bool operator!=(const composite_subscription& lhs, const composite_subscription& rhs) { + return !(lhs == rhs); +} + +//static +RXCPP_SELECT_ANY composite_subscription composite_subscription::shared_empty = composite_subscription(detail::tag_composite_subscription_empty()); } diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 6b37ca3..76b7f9e 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -227,12 +227,12 @@ public: } maybe& operator=(const T& other) { - set(other); + reset(other); return *this; } maybe& operator=(const maybe& other) { if (const T* pother = other.get()) { - set(*pother); + reset(*pother); } else { reset(); } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 411bd43..6d3cf6f 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -251,9 +251,9 @@ public: } auto sharedThis = std::static_pointer_cast(this->shared_from_this()); - o.add(dynamic_subscription([sharedThis, index]() { + o.add([sharedThis, index]() { sharedThis->sv[index] = rxn::subscription(sharedThis->sv[index].subscribe(), sharedThis->sc->clock()); - })); + }); } virtual std::vector subscriptions() const { @@ -313,9 +313,9 @@ public: auto index = sv.size() - 1; auto sharedThis = std::static_pointer_cast(this->shared_from_this()); - o.add(dynamic_subscription([sharedThis, index]() { + o.add([sharedThis, index]() { sharedThis->sv[index] = rxn::subscription(sharedThis->sv[index].subscribe(), sharedThis->sc->clock()); - })); + }); } virtual std::vector subscriptions() const { diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index dffa37c..e892828 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -2,8 +2,8 @@ #pragma once -#if !defined(RXCPP_RX_SCHEDULER_SUBJECT_HPP) -#define RXCPP_RX_SCHEDULER_SUBJECT_HPP +#if !defined(RXCPP_RX_SUBJECT_HPP) +#define RXCPP_RX_SUBJECT_HPP #include "../rx-includes.hpp" @@ -200,7 +200,11 @@ class subject detail::multicast_observer s; public: - explicit subject(composite_subscription cs = composite_subscription()) + subject() + : s(lifetime) + { + } + explicit subject(composite_subscription cs) : lifetime(cs) , s(cs) { @@ -210,11 +214,8 @@ public: return s.has_observers(); } - subscriber>> get_subscriber(composite_subscription cs = composite_subscription()) const { - auto lt = lifetime; - auto token = lt.add(cs); - cs.add(make_subscription([token, lt](){lt.remove(token);})); - return make_subscriber(cs, observer>(s)); + subscriber>> get_subscriber() const { + return make_subscriber(lifetime, observer>(s)); } observable get_observable() const { diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp new file mode 100644 index 0000000..60ce46a --- /dev/null +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -0,0 +1,214 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SYNCHRONIZE_HPP) +#define RXCPP_RX_SYNCHRONIZE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace subjects { + +namespace detail { + +template +class synchronize_observer : public detail::multicast_observer +{ + typedef synchronize_observer this_type; + typedef detail::multicast_observer base_type; + + struct synchronize_observer_state : public std::enable_shared_from_this + { + typedef rxn::notification notification_type; + typedef typename notification_type::type base_notification_type; + typedef std::deque queue_type; + + struct mode + { + enum type { + Invalid = 0, + Processing, + Empty, + Disposed + }; + }; + + mutable std::mutex lock; + mutable std::condition_variable wake; + mutable queue_type queue; + composite_subscription lifetime; + rxsc::worker processor; + mutable typename mode::type current; + subscriber destination; + + void ensure_processing(std::unique_lock& guard) const { + if (!guard.owns_lock()) { + abort(); + } + if (current == mode::Empty) { + current = mode::Processing; + auto keepAlive = this->shared_from_this(); + processor.schedule(lifetime, [keepAlive, this](const rxsc::schedulable& self){ + try { + std::unique_lock guard(lock); + if (!lifetime.is_subscribed() || !destination.is_subscribed()) { + current = mode::Disposed; + queue.clear(); + guard.unlock(); + lifetime.unsubscribe(); + destination.unsubscribe(); + return; + } + if (queue.empty()) { + current = mode::Empty; + return; + } + auto notification = std::move(queue.front()); + queue.pop_front(); + guard.unlock(); + notification->accept(destination); + self(); + } catch(...) { + destination.on_error(std::current_exception()); + std::unique_lock guard(lock); + current = mode::Empty; + } + }); + } + } + + synchronize_observer_state(rxsc::worker w, composite_subscription cs, subscriber scbr) + : lifetime(cs) + , processor(w) + , current(mode::Empty) + , destination(scbr) + { + } + + template + void on_next(V v) const { + if (lifetime.is_subscribed()) { + std::unique_lock guard(lock); + queue.push_back(notification_type::on_next(std::move(v))); + wake.notify_one(); + ensure_processing(guard); + } + } + void on_error(std::exception_ptr e) const { + if (lifetime.is_subscribed()) { + std::unique_lock guard(lock); + queue.push_back(notification_type::on_error(e)); + wake.notify_one(); + ensure_processing(guard); + } + } + void on_completed() const { + if (lifetime.is_subscribed()) { + std::unique_lock guard(lock); + queue.push_back(notification_type::on_completed()); + wake.notify_one(); + ensure_processing(guard); + } + } + }; + + std::shared_ptr state; + +public: + synchronize_observer(rxsc::worker w, composite_subscription cs) + : base_type(cs) + , state(std::make_shared( + w, cs, make_subscriber(cs, make_observer_dynamic( *static_cast(this) )))) + {} + + template + void on_next(V v) const { + state->on_next(std::move(v)); + } + void on_error(std::exception_ptr e) const { + state->on_error(e); + } + void on_completed() const { + state->on_completed(); + } +}; + +} + +template +class synchronize +{ + rxsc::worker controller; + composite_subscription lifetime; + detail::synchronize_observer s; + +public: + explicit synchronize(rxsc::worker w, composite_subscription cs = composite_subscription()) + : controller(w) + , lifetime(cs) + , s(w, cs) + { + } + + bool has_observers() const { + return s.has_observers(); + } + + subscriber get_subscriber() const { + return make_subscriber(lifetime, make_observer_dynamic(observer>(s))); + } + + observable get_observable() const { + return make_observable_dynamic([this](subscriber o){ + this->s.add(std::move(o)); + }); + } +}; + +// +// this type is used by operators that subscribe to +// multiple sources to ensure that the notifications are serialized +// +class synchronize_observable +{ + rxsc::scheduler factory; + rxsc::worker controller; +public: + synchronize_observable(rxsc::scheduler sc) + : factory(sc) + , controller(sc.create_worker()) + { + } + synchronize_observable(const synchronize_observable& o) + : factory(o.factory) + // new worker for each copy. this spreads work across threads + // but keeps each use serialized + , controller(factory.create_worker()) + { + } + synchronize_observable(synchronize_observable&& o) + : factory(std::move(o.factory)) + , controller(std::move(o.controller)) + { + } + synchronize_observable& operator=(synchronize_observable o) + { + factory = std::move(o.factory); + controller = std::move(o.controller); + return *this; + } + template + auto operator()(Observable o) + -> decltype(o.synchronize(controller).ref_count()) { + return o.synchronize(controller).ref_count(); + static_assert(is_observable::value, "can only synchronize observables"); + } +}; + +} + +} + +#endif diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 2d5b0f9..38f43ed 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 500; +static const int static_tripletCount = 50; SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -51,7 +51,7 @@ SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ } } -SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ +SCENARIO("pythagorian ranges", "[hide][range][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; GIVEN("some ranges"){ WHEN("generating pythagorian triplets"){ @@ -68,21 +68,23 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ auto triples = rxs::range(1, sc) .flat_map( - [&c, sc](int z){ return rxs::range(1, z, 1, sc) - .flat_map( - [&c, sc, z](int x){ return rxs::range(x, z, 1, sc) - .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) - .map([z, x](int y){return std::make_tuple(x, y, z);}) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic();}, + [&c, sc](int z){ + return rxs::range(1, z, 1, sc) + .flat_map( + [&c, sc, z](int x){ + return rxs::range(x, z, 1, sc) + .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}); triples .take(tripletCount) .subscribe( - [&ct](std::tuple triplet){++ct;}, + rxu::apply_to([&ct](int x,int y,int z){++ct;}), [](std::exception_ptr){abort();}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -93,6 +95,63 @@ SCENARIO("pythagorian ranges", "[hide][for][pythagorian][perf]"){ } } +SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + rx::composite_subscription lifetime; + + auto sc = rxsc::make_event_loop(); + auto so = rxsub::synchronize_observable(sc); + + int c = 0; + int ct = 0; + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, sc) + .flat_map( + [&c, sc, so](int z){ + return rxs::range(1, z, 1, sc) + .flat_map( + [&c, sc, z](int x){ + return rxs::range(x, z, 1, sc) + .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) + .map([z, x](int y){return std::make_tuple(x, y, z);});}, + [](int x, std::tuple triplet){return triplet;}, + so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}, + so); + triples + .take(tripletCount) + .subscribe( + lifetime, + rxu::apply_to([&ct](int x,int y,int z){++ct;}), + [](std::exception_ptr){abort();}, + [&](){ + lifetime.unsubscribe(); + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return !lifetime.is_subscribed();}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} + SCENARIO("flat_map completes", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 2ea1999..83f90e7 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -84,14 +84,10 @@ SCENARIO("observer traits", "[observer][traits]"){ SCENARIO("non-observer traits", "[observer][traits]"){ GIVEN("given some subscription types"){ auto empty = [](){}; - rx::dynamic_subscription ds(empty); rx::static_subscription ss(empty); auto es = rx::make_subscription(); rx::composite_subscription cs; WHEN("tested"){ - THEN("is_observer value is false for dynamic_subscription"){ - REQUIRE(!rx::is_observer::value); - } THEN("is_observer value is false for static_subscription"){ REQUIRE(!rx::is_observer::value); } diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 3244946..f2959f7 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -6,18 +6,10 @@ namespace rx=rxcpp; SCENARIO("subscription traits", "[subscription][traits]"){ GIVEN("given some subscription types"){ auto empty = [](){}; - rx::dynamic_subscription ds(empty); - rx::static_subscription ss(empty); auto es = rx::make_subscription(); rx::composite_subscription cs; WHEN("tested"){ - THEN("is_subscription value is true for dynamic_subscription"){ - REQUIRE(rx::is_subscription::value); - } - THEN("is_subscription value is true for static_subscription"){ - REQUIRE(rx::is_subscription::value); - } - THEN("is_subscription value is true for subscription"){ + THEN("is_subscription value is true for empty subscription"){ REQUIRE(rx::is_subscription::value); } THEN("is_subscription value is true for composite_subscription"){ @@ -84,41 +76,6 @@ SCENARIO("subscription static", "[subscription]"){ } } -SCENARIO("subscription dynamic", "[subscription]"){ - GIVEN("given a subscription"){ - int i=0; - auto s = rx::make_subscription(rx::dynamic_subscription([&i](){++i;})); - WHEN("not used"){ - THEN("is subscribed"){ - REQUIRE(s.is_subscribed()); - } - THEN("i is 0"){ - REQUIRE(i == 0); - } - } - WHEN("used"){ - THEN("is not subscribed when unsubscribed once"){ - s.unsubscribe(); - REQUIRE(!s.is_subscribed()); - } - THEN("is not subscribed when unsubscribed twice"){ - s.unsubscribe(); - s.unsubscribe(); - REQUIRE(!s.is_subscribed()); - } - THEN("i is 1 when unsubscribed once"){ - s.unsubscribe(); - REQUIRE(i == 1); - } - THEN("i is 1 when unsubscribed twice"){ - s.unsubscribe(); - s.unsubscribe(); - REQUIRE(i == 1); - } - } - } -} - SCENARIO("subscription empty", "[subscription]"){ GIVEN("given an empty subscription"){ auto s = rx::make_subscription(); @@ -147,7 +104,7 @@ SCENARIO("subscription composite", "[subscription]"){ rx::composite_subscription s; s.add(rx::make_subscription()); s.add(rx::make_subscription([&i](){++i;})); - s.add(rx::make_subscription(rx::dynamic_subscription([&i](){++i;}))); + s.add([&i](){++i;}); WHEN("not used"){ THEN("is subscribed"){ REQUIRE(s.is_subscribed()); -- GitLab From ce504177a24794d13b9f9832f5b972ba9ba94436 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 22 May 2014 07:08:20 -0700 Subject: [PATCH 288/782] add long tags to long tests --- Rx/v2/test/subjects/subject.cpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 3a17a36..7b8a769 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -202,7 +202,7 @@ public: onnext(v); return ready.get_future();} }; } -SCENARIO("for loop calls std::future on_next(int)", "[hide][for][asyncobserver][future][perf]"){ +SCENARIO("for loop calls std::future on_next(int)", "[hide][for][asyncobserver][future][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("a for loop"){ WHEN("calling on_next 100 million times"){ @@ -307,7 +307,7 @@ SCENARIO("range calls subscriber", "[hide][range][subscriber][perf]"){ } } -SCENARIO("for loop calls subject", "[hide][for][subject][subjects][perf]"){ +SCENARIO("for loop calls subject", "[hide][for][subject][subjects][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("a for loop and a subject"){ WHEN("multicasting a million ints"){ @@ -373,7 +373,7 @@ SCENARIO("for loop calls subject", "[hide][for][subject][subjects][perf]"){ } } -SCENARIO("range calls subject", "[hide][range][subject][subjects][perf]"){ +SCENARIO("range calls subject", "[hide][range][subject][subjects][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("a range and a subject"){ WHEN("multicasting a million ints"){ @@ -437,7 +437,7 @@ SCENARIO("range calls subject", "[hide][range][subject][subjects][perf]"){ } } -SCENARIO("schedule_periodically", "[hide][periodically][scheduler][perf]"){ +SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("schedule_periodically"){ WHEN("the period is 1sec and the initial is 2sec"){ @@ -460,7 +460,7 @@ SCENARIO("schedule_periodically", "[hide][periodically][scheduler][perf]"){ } } -SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][perf]"){ +SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("schedule_periodically_duration"){ WHEN("the period is 1sec and the initial is 2sec"){ @@ -503,6 +503,7 @@ SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][p } } } + SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ -- GitLab From 09d7c3f63530aec3b6cbaac32a166152092e62e5 Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS Open Tech)" Date: Thu, 22 May 2014 08:28:41 -0700 Subject: [PATCH 289/782] compiles and runs on windows --- Rx/v2/src/rxcpp/rx-observable.hpp | 1 - Rx/v2/src/rxcpp/rx-subscription.hpp | 23 +++++++++++++---------- Rx/v2/test/operators/flat_map.cpp | 4 +++- Rx/v2/test/operators/lift.cpp | 16 +++++++++------- Rx/v2/test/subjects/subject.cpp | 2 +- 5 files changed, 26 insertions(+), 20 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 5c197a3..c84a55a 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -194,7 +194,6 @@ private: if (rxsc::current_thread::is_schedule_required()) { auto sc = rxsc::make_current_thread(); sc.create_worker(o.get_subscription()).schedule( - o.get_subscription(), [=](const rxsc::schedulable& scbl) { safe_subscribe(); }); diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 527d52b..60f445c 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -132,7 +132,7 @@ public: template explicit subscription(U u, typename std::enable_if::value && is_subscription::value, void**>::type = nullptr) // intentionally slice - : state(std::move(static_cast(u).state)) + : state(std::move((*static_cast(&u)).state)) { if (!state) { abort(); @@ -321,11 +321,6 @@ public: if (!state) { abort(); } - if (s == static_cast(*this)) { - // do not nest the same subscription - abort(); - //return s.get_weak(); - } return state->add(std::move(s)); } inline void remove(weak_subscription w) const { @@ -370,7 +365,7 @@ public: composite_subscription() : inner_type() - , subscription(static_cast(*this)) + , subscription(*static_cast(this)) { } @@ -388,7 +383,7 @@ public: composite_subscription& operator=(composite_subscription o) { inner_type::operator=(std::move(o)); - subscription::operator=(std::move(static_cast(o))); + subscription::operator=(std::move(*static_cast(&o))); return *this; } @@ -399,14 +394,22 @@ public: using subscription::is_subscribed; using subscription::unsubscribe; - using inner_type::add; using inner_type::remove; using inner_type::clear; + inline weak_subscription add(subscription s) const { + if (s == static_cast(*this)) { + // do not nest the same subscription + abort(); + //return s.get_weak(); + } + return inner_type::add(std::move(s)); + } + template auto add(F f) const -> typename std::enable_if::value, weak_subscription>::type { - return inner_type::add(make_subscription(std::move(f))); + return add(make_subscription(std::move(f))); } }; diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 38f43ed..258171d 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -123,7 +123,9 @@ SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagori [&c, sc, z](int x){ return rxs::range(x, z, 1, sc) .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) - .map([z, x](int y){return std::make_tuple(x, y, z);});}, + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, [](int x, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 diff --git a/Rx/v2/test/operators/lift.cpp b/Rx/v2/test/operators/lift.cpp index a4c596d..6952d44 100644 --- a/Rx/v2/test/operators/lift.cpp +++ b/Rx/v2/test/operators/lift.cpp @@ -279,15 +279,17 @@ SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][ }; return xs .lift([=](rx::subscriber dest){ + // VS2013 deduction issue requires dynamic (type-forgetting) return rx::make_subscriber( dest, - [=](int n){ - bool pass = false; - try{pass = predicate(n);} catch(...){dest.on_error(std::current_exception());}; - if (pass) {dest.on_next(n);} - }, - [=](std::exception_ptr e){dest.on_error(e);}, - [=](){dest.on_completed();}); + rx::make_observer_dynamic( + [=](int n){ + bool pass = false; + try{pass = predicate(n);} catch(...){dest.on_error(std::current_exception());}; + if (pass) {dest.on_next(n);} + }, + [=](std::exception_ptr e){dest.on_error(e);}, + [=](){dest.on_completed();})); }) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 7b8a769..ea475a6 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -21,7 +21,7 @@ namespace rxt=rxcpp::test; const int static_onnextcalls = 100000000; int aliased = 0; -SCENARIO("for loop locks mutex", "[hide][for][mutex][perf]"){ +SCENARIO("for loop locks mutex", "[hide][for][mutex][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("a for loop"){ WHEN("locking mutex 100 million times"){ -- GitLab From 18260f866b08179891eb1202fbe9b4441e58f1b6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 28 May 2014 16:14:41 -0700 Subject: [PATCH 290/782] lifetime and thread fixes --- Rx/v2/src/rxcpp/operators/rx-ref_count.hpp | 37 ++++++--- Rx/v2/src/rxcpp/operators/rx-take.hpp | 12 ++- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 15 ++-- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 89 +++++++++++++-------- 4 files changed, 99 insertions(+), 54 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp index 52a3d30..c289790 100644 --- a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -18,28 +18,43 @@ struct ref_count : public operator_base { typedef typename std::decay::type source_type; - source_type source; - long subscribers; - composite_subscription connection; + struct ref_count_state : public std::enable_shared_from_this + { + explicit ref_count_state(source_type o) + : source(std::move(o)) + , subscribers(0) + { + } + + source_type source; + std::mutex lock; + long subscribers; + composite_subscription connection; + }; + std::shared_ptr state; explicit ref_count(source_type o) - : source(std::move(o)) - , subscribers(0) + : state(std::make_shared(std::move(o))) { } template void on_subscribe(Subscriber&& o) { - auto needConnect = ++subscribers == 1; + std::unique_lock guard(state->lock); + auto needConnect = ++state->subscribers == 1; + auto keepAlive = state; + guard.unlock(); o.add( - [this](){ - if (--this->subscribers == 0) { - this->connection.unsubscribe(); + [keepAlive](){ + std::unique_lock guard(keepAlive->lock); + if (--keepAlive->subscribers == 0) { + keepAlive->connection.unsubscribe(); + keepAlive->connection = composite_subscription(); } }); - source.subscribe(std::forward(o)); + keepAlive->source.subscribe(std::forward(o)); if (needConnect) { - connection = source.connect(); + keepAlive->source.connect(keepAlive->connection); } } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index ff903f0..2b2f5b7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -65,17 +65,23 @@ struct take : public operator_base // take a copy of the values for each subscription auto state = std::shared_ptr(new state_type(initial, s)); + composite_subscription source_lifetime; + + s.add(source_lifetime); + state->source.subscribe( - // share subscription lifetime - state->out, + // split subscription lifetime + source_lifetime, // on_next - [state](T t) { + [state, source_lifetime](T t) { if (state->mode_value < mode::triggered) { if (--state->count > 0) { state->out.on_next(t); } else { state->mode_value = mode::triggered; state->out.on_next(t); + // must shutdown source before signaling completion + source_lifetime.unsubscribe(); state->out.on_completed(); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 35c7fe6..6c7389e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -60,11 +60,15 @@ struct take_until : public operator_base , busy(0) , out(oarg) { + out.add(trigger_lifetime); + out.add(source_lifetime); } mutable std::atomic mode_value; mutable std::atomic busy; mutable std::mutex finish_lock; mutable std::exception_ptr exception; + composite_subscription trigger_lifetime; + composite_subscription source_lifetime; output_type out; }; // take a copy of the values for each subscription @@ -83,6 +87,8 @@ struct take_until : public operator_base st->mode_value.exchange(mode::stopped); guard.unlock(); if (fin == mode::triggered) { + st->trigger_lifetime.unsubscribe(); + st->source_lifetime.unsubscribe(); st->out.on_completed(); } else if (fin == mode::errored) { st->out.on_error(ex); @@ -97,14 +103,11 @@ struct take_until : public operator_base }; - composite_subscription trigger_lifetime; - state->out.add(trigger_lifetime); - state->trigger.subscribe( // share parts of subscription state->out, // new lifetime - trigger_lifetime, + state->trigger_lifetime, // on_next [state](const typename trigger_source_type::value_type&) { activity finisher(state); @@ -130,8 +133,8 @@ struct take_until : public operator_base ); state->source.subscribe( - // share subscription lifetime - state->out, + // split subscription lifetime + state->source_lifetime, // on_next [state](T t) { // diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp index 6dcfb9f..89a0a12 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -25,59 +25,80 @@ private: typedef new_worker this_type; new_worker(const this_type&); - typedef detail::schedulable_queue< - typename clock_type::time_point> queue_item_time; + struct new_worker_state : public std::enable_shared_from_this + { + typedef detail::schedulable_queue< + typename clock_type::time_point> queue_item_time; + + typedef queue_item_time::item_type item_type; + + virtual ~new_worker_state() + { + std::unique_lock guard(lock); + if (worker.joinable() && worker.get_id() != std::this_thread::get_id()) { + lifetime.unsubscribe(); + guard.unlock(); + worker.join(); + } + else { + lifetime.unsubscribe(); + worker.detach(); + } + } - typedef queue_item_time::item_type item_type; + explicit new_worker_state(composite_subscription cs) + : lifetime(cs) + { + } + + composite_subscription lifetime; + mutable std::mutex lock; + mutable std::condition_variable wake; + mutable queue_item_time queue; + std::thread worker; + recursion r; + }; - composite_subscription lifetime; - mutable std::mutex lock; - mutable std::condition_variable wake; - mutable queue_item_time queue; - std::thread worker; - recursion r; + std::shared_ptr state; public: virtual ~new_worker() { - { - std::unique_lock guard(lock); - lifetime.unsubscribe(); - } - worker.join(); } new_worker(composite_subscription cs, thread_factory& tf) - : lifetime(cs) + : state(std::make_shared(cs)) { - lifetime.add(make_subscription([this](){ - wake.notify_one(); - })); + auto keepAlive = state; + + state->lifetime.add([keepAlive](){ + keepAlive->wake.notify_one(); + }); - worker = tf([this](){ + state->worker = tf([keepAlive](){ for(;;) { - std::unique_lock guard(lock); - if (queue.empty()) { - wake.wait(guard, [this](){ - return !lifetime.is_subscribed() || !queue.empty(); + std::unique_lock guard(keepAlive->lock); + if (keepAlive->queue.empty()) { + keepAlive->wake.wait(guard, [keepAlive](){ + return !keepAlive->lifetime.is_subscribed() || !keepAlive->queue.empty(); }); } - if (!lifetime.is_subscribed()) { + if (!keepAlive->lifetime.is_subscribed()) { break; } - auto& peek = queue.top(); + auto& peek = keepAlive->queue.top(); if (!peek.what.is_subscribed()) { - queue.pop(); + keepAlive->queue.pop(); continue; } if (clock_type::now() < peek.when) { - wake.wait_until(guard, peek.when); + keepAlive->wake.wait_until(guard, peek.when); continue; } auto what = peek.what; - queue.pop(); - r.reset(queue.empty()); + keepAlive->queue.pop(); + keepAlive->r.reset(keepAlive->queue.empty()); guard.unlock(); - what(r.get_recurse()); + what(keepAlive->r.get_recurse()); } }); } @@ -92,11 +113,11 @@ private: virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { if (scbl.is_subscribed()) { - std::unique_lock guard(lock); - queue.push(item_type(when, scbl)); - r.reset(false); + std::unique_lock guard(state->lock); + state->queue.push(new_worker_state::item_type(when, scbl)); + state->r.reset(false); } - wake.notify_one(); + state->wake.notify_one(); } }; -- GitLab From 9b522717641458eaa74f1da44f4a26eb0e3be178 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 28 May 2014 16:15:15 -0700 Subject: [PATCH 291/782] remove aborts triggered by thread interleaves --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 2 +- Rx/v2/src/rxcpp/rx-subscriber.hpp | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 5713b58..d945e17 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -585,7 +585,7 @@ public: /// invokes the action inline void operator()(const recurse& r) const { if (!is_subscribed()) { - abort(); + return; } detacher protect(this); activity(*this, r); diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 939d76c..da432eb 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -105,7 +105,7 @@ public: template void on_next(V&& v) const { if (!is_subscribed()) { - abort(); + return; } detacher protect(this); destination.on_next(std::forward(v)); @@ -113,14 +113,14 @@ public: } void on_error(std::exception_ptr e) const { if (!is_subscribed()) { - abort(); + return; } detacher protect(this); destination.on_error(e); } void on_completed() const { if (!is_subscribed()) { - abort(); + return; } detacher protect(this); destination.on_completed(); -- GitLab From 51ba3ea83550edcf23b14229274709a0184dd4ae Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 28 May 2014 16:15:37 -0700 Subject: [PATCH 292/782] small test changes --- Rx/v2/test/operators/flat_map.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 258171d..921df08 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -105,9 +105,8 @@ SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagori std::mutex lock; std::condition_variable wake; - rx::composite_subscription lifetime; - auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); auto so = rxsub::synchronize_observable(sc); int c = 0; @@ -122,7 +121,12 @@ SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagori .flat_map( [&c, sc, z](int x){ return rxs::range(x, z, 1, sc) - .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) + .filter([&c, z, x](int y){ + ++c; + if (x*x + y*y == z*z) { + return true;} + else { + return false;}}) .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, @@ -135,21 +139,19 @@ SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagori triples .take(tripletCount) .subscribe( - lifetime, - rxu::apply_to([&ct](int x,int y,int z){++ct;}), + rxu::apply_to([&ct](int x,int y,int z){ + ++ct;}), [](std::exception_ptr){abort();}, [&](){ - lifetime.unsubscribe(); wake.notify_one();}); std::unique_lock guard(lock); - wake.wait(guard, [&](){return !lifetime.is_subscribed();}); + wake.wait(guard); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); std::cout << "pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; - } } } -- GitLab From 0a8aa7827debc4118464be3416edddd27e9803ba Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 28 May 2014 23:22:35 -0700 Subject: [PATCH 293/782] add merge --- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 174 ++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 69 +++++++++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/merge.cpp | 144 ++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 6 files changed, 390 insertions(+), 1 deletion(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-merge.hpp create mode 100644 Rx/v2/test/operators/merge.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 96e7ea6..f120bf7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -220,7 +220,7 @@ public: auto operator()(Observable&& source) -> observable::value_type, flat_map> { return observable::value_type, flat_map>( - flat_map(std::forward(source), std::move(selectorCollection), std::move(selectorResult), std::move(sourceFilter))); + flat_map(std::forward(source), selectorCollection, selectorResult, sourceFilter)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp new file mode 100644 index 0000000..b719bcd --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -0,0 +1,174 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_MERGE_HPP) +#define RXCPP_OPERATORS_RX_MERGE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct merge : public operator_base::type::value_type::value_type> +{ + typedef merge this_type; + + typedef typename std::decay::type source_type; + typedef typename source_type::value_type source_value_type; + typedef typename std::decay::type source_filter_type; + + struct values + { + values(source_type o, source_filter_type sf) + : source(std::move(o)) + , sourceFilter(std::move(sf)) + { + } + source_type source; + source_filter_type sourceFilter; + }; + values initial; + + merge(source_type o, source_filter_type sf) + : initial(std::move(o), std::move(sf)) + { + } + + template + void on_subscribe(Subscriber&& scbr) { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename std::decay::type output_type; + + struct merge_state_type + : public std::enable_shared_from_this + , public values + { + merge_state_type(values i, output_type oarg) + : values(std::move(i)) + , pendingCompletions(0) + , out(std::move(oarg)) + { + } + // on_completed on the output must wait until all the + // subscriptions have received on_completed + int pendingCompletions; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::shared_ptr(new merge_state_type(initial, std::forward(scbr))); + + composite_subscription outercs; + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.add(outercs); + + auto source = on_exception( + [&](){return state->sourceFilter(state->source);}, + state->out); + if (source.empty()) { + return; + } + + ++state->pendingCompletions; + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + source->subscribe( + state->out, + outercs, + // on_next + [state](source_value_type st) { + + composite_subscription innercs; + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + auto innercstoken = state->out.add(innercs); + + innercs.add(make_subscription([state, innercstoken](){ + state->out.remove(innercstoken); + })); + + auto selectedSource = on_exception( + [&](){return state->sourceFilter(st);}, + state->out); + if (selectedSource.empty()) { + return; + } + + ++state->pendingCompletions; + // this subscribe does not share the source subscription + // so that when it is unsubscribed the source will continue + selectedSource->subscribe( + state->out, + innercs, + // on_next + [state, st](value_type ct) { + state->out.on_next(std::move(ct)); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + //on_completed + [state](){ + if (--state->pendingCompletions == 0) { + state->out.on_completed(); + } + } + ); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (--state->pendingCompletions == 0) { + state->out.on_completed(); + } + } + ); + } +}; + +template +class merge_factory +{ + typedef typename std::decay::type source_filter_type; + + source_filter_type sourceFilter; +public: + merge_factory(source_filter_type sf) + : sourceFilter(std::move(sf)) + { + } + + template + auto operator()(Observable&& source) + -> observable::value_type, merge> { + return observable::value_type, merge>( + merge(std::forward(source), sourceFilter)); + } +}; + +} + +template +auto merge(SourceFilter&& sf) + -> detail::merge_factory { + return detail::merge_factory(std::forward(sf)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index c84a55a..a842f18 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -101,6 +101,9 @@ class dynamic_observable }; std::shared_ptr state; + template + friend bool operator==(const dynamic_observable&, const dynamic_observable&); + template void construct(SO&& source, rxs::tag_source&&) { typename std::decay::type so = std::forward(source); @@ -142,6 +145,15 @@ public: } }; +template +inline bool operator==(const dynamic_observable& lhs, const dynamic_observable& rhs) { + return lhs.state == rhs.state; +} +template +inline bool operator!=(const dynamic_observable& lhs, const dynamic_observable& rhs) { + return !(lhs == rhs); +} + template observable make_observable_dynamic(Source&& s) { return observable(dynamic_observable(std::forward(s))); @@ -162,6 +174,9 @@ private: template friend class observable; + template + friend bool operator==(const observable&, const observable&); + template auto detail_subscribe(Subscriber&& scrbr) const -> composite_subscription { @@ -309,6 +324,51 @@ public: rxo::detail::map(*this, std::forward(s))); } + template::value> + struct merge_result; + + template + struct merge_result + { + typedef + observable< + typename this_type::value_type::value_type, + rxo::detail::merge, SourceFilter>> + type; + static type make(const this_type* that, SourceFilter sf) { + return type(rxo::detail::merge, SourceFilter>(*that, sf)); + } + }; + template + struct merge_result + { + typedef this_type type; + static type make(const this_type* that, SourceFilter) { + return *that; + } + }; + + /// merge -> + /// for each item from this observable subscribe. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + auto merge() const + -> typename merge_result::type { + return merge_result::make(this, identity_observable()); + } + + /// merge -> + /// for each item from this observable subscribe. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + template + auto merge(SourceFilter&& sf) const + -> typename std::enable_if::value, + observable::value_type, rxo::detail::merge>>::type { + return observable::value_type, rxo::detail::merge>( + rxo::detail::merge(*this, std::forward(sf))); + } + /// flat_map (AKA SelectMany) -> /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. @@ -378,6 +438,15 @@ public: } }; +template +inline bool operator==(const observable& lhs, const observable& rhs) { + return lhs.source_operator == rhs.source_operator; +} +template +inline bool operator!=(const observable& lhs, const observable& rhs) { + return !(lhs == rhs); +} + // observable<> has static methods to construct observable sources and adaptors. // observable<> is not constructable template<> diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 48c84d5..7e1439c 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -38,6 +38,7 @@ namespace rxo=operators; #include "operators/rx-subscribe.hpp" #include "operators/rx-filter.hpp" #include "operators/rx-map.hpp" +#include "operators/rx-merge.hpp" #include "operators/rx-flat_map.hpp" #include "operators/rx-multicast.hpp" #include "operators/rx-publish.hpp" diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp new file mode 100644 index 0000000..1b43592 --- /dev/null +++ b/Rx/v2/test/operators/merge.cpp @@ -0,0 +1,144 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + + +SCENARIO("merge completes", "[flat_map][map][operators]"){ + GIVEN("1 hot observable with 3 cold observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages> mo; + typedef rxn::subscription life; + + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + typedef mo::recorded_type orecord; + auto oon_next = mo::on_next; + auto oon_completed = mo::on_completed; + auto osubscribe = mo::subscribe; + + record messages1[] = { + on_next(10, 101), + on_next(20, 102), + on_next(110, 103), + on_next(120, 104), + on_next(210, 105), + on_next(220, 106), + on_completed(230) + }; + auto ys1 = sc.make_cold_observable(messages1); + + record messages2[] = { + on_next(10, 201), + on_next(20, 202), + on_next(30, 203), + on_next(40, 204), + on_completed(50) + }; + auto ys2 = sc.make_cold_observable(messages2); + + record messages3[] = { + on_next(10, 301), + on_next(20, 302), + on_next(30, 303), + on_next(40, 304), + on_next(120, 305), + on_completed(150) + }; + auto ys3 = sc.make_cold_observable(messages3); + + orecord omessages[] = { + oon_next(300, ys1), + oon_next(400, ys2), + oon_next(500, ys3), + oon_completed(600) + }; + auto xs = sc.make_hot_observable(omessages); + + WHEN("each int is merged"){ + + auto res = w.start( + [&]() { + return xs + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged ints"){ + record items[] = { + on_next(310, 101), + on_next(320, 102), + on_next(410, 103), + on_next(410, 201), + on_next(420, 104), + on_next(420, 202), + on_next(430, 203), + on_next(440, 204), + on_next(510, 105), + on_next(510, 301), + on_next(520, 106), + on_next(520, 302), + on_next(530, 303), + on_next(540, 304), + on_next(620, 305), + on_completed(650) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + life items[] = { + subscribe(200, 600) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys1"){ + life items[] = { + subscribe(300, 530) + }; + auto required = rxu::to_vector(items); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys2"){ + life items[] = { + subscribe(400, 450) + }; + auto required = rxu::to_vector(items); + auto actual = ys2.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys3"){ + life items[] = { + subscribe(500, 650) + }; + auto required = rxu::to_vector(items); + auto actual = ys3.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b09e5be..52f554a 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,6 +42,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/operators/merge.cpp ${V2_TEST_DIR}/operators/lift.cpp ${V2_TEST_DIR}/operators/filter.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp -- GitLab From 53f772f5252f1c6cb834460726a7ca82fcccc6d8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 28 May 2014 23:34:36 -0700 Subject: [PATCH 294/782] clang compiles --- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index b719bcd..382e17a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -20,6 +20,7 @@ struct merge : public operator_base::type::value typedef typename std::decay::type source_type; typedef typename source_type::value_type source_value_type; + typedef typename source_value_type::value_type value_type; typedef typename std::decay::type source_filter_type; struct values -- GitLab From aef88fd9c233609af14ba00deba68140cbfc6393 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 29 May 2014 14:59:07 -0700 Subject: [PATCH 295/782] add concat_map --- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 253 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 30 ++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/concat_map.cpp | 148 ++++++++++++ Rx/v2/test/operators/flat_map.cpp | 8 +- projects/CMake/CMakeLists.txt | 1 + 6 files changed, 433 insertions(+), 8 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-concat_map.hpp create mode 100644 Rx/v2/test/operators/concat_map.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp new file mode 100644 index 0000000..9b21368 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -0,0 +1,253 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_CONCATMAP_HPP) +#define RXCPP_OPERATORS_RX_CONCATMAP_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct concat_traits { + typedef typename std::decay::type source_type; + typedef typename std::decay::type collection_selector_type; + typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type source_filter_type; + + typedef typename source_type::value_type source_value_type; + + struct tag_not_valid {}; + template + static auto collection_check(int) -> decltype((*(CCS*)nullptr)(*(CV*)nullptr)); + template + static tag_not_valid collection_check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "concat_map CollectionSelector must be a function with the signature observable(concat_map::source_value_type)"); + + typedef decltype((*(collection_selector_type*)nullptr)((*(source_value_type*)nullptr))) collection_type; + +//#if _MSC_VER >= 1900 + static_assert(is_observable::value, "concat_map CollectionSelector must return an observable"); +//#endif + + typedef typename collection_type::value_type collection_value_type; + + template + static auto result_check(int) -> decltype((*(CRS*)nullptr)(*(CV*)nullptr, *(CCV*)nullptr)); + template + static tag_not_valid result_check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "concat_map ResultSelector must be a function with the signature concat_map::value_type(concat_map::source_value_type, concat_map::collection_value_type)"); + + typedef decltype((*(result_selector_type*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; +}; + +template +struct concat_map + : public operator_base::value_type> +{ + typedef concat_map this_type; + typedef concat_traits traits; + + typedef typename traits::source_type source_type; + typedef typename traits::collection_selector_type collection_selector_type; + typedef typename traits::result_selector_type result_selector_type; + + typedef typename traits::source_value_type source_value_type; + typedef typename traits::collection_type collection_type; + typedef typename traits::collection_value_type collection_value_type; + + typedef typename traits::source_filter_type source_filter_type; + + struct values + { + values(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + : source(std::move(o)) + , selectCollection(std::move(s)) + , selectResult(std::move(rs)) + , sourceFilter(std::move(sf)) + { + } + source_type source; + collection_selector_type selectCollection; + result_selector_type selectResult; + source_filter_type sourceFilter; + }; + values initial; + + concat_map(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + : initial(std::move(o), std::move(s), std::move(rs), std::move(sf)) + { + } + + template + void on_subscribe(Subscriber&& scbr) { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename std::decay::type output_type; + + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(values i, output_type oarg) + : values(std::move(i)) + , sourceLifetime(composite_subscription::empty()) + , collectionLifetime(composite_subscription::empty()) + , out(std::move(oarg)) + { + } + + void subscribe_to(source_value_type st) + { + auto state = this->shared_from_this(); + + auto selectedCollection = on_exception( + [&](){return state->selectCollection(st);}, + state->out); + if (selectedCollection.empty()) { + return; + } + + collectionLifetime = composite_subscription(); + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + auto innercstoken = state->out.add(collectionLifetime); + + collectionLifetime.add(make_subscription([state, innercstoken](){ + state->out.remove(innercstoken); + })); + + auto selectedSource = on_exception( + [&](){return state->sourceFilter(selectedCollection.get());}, + state->out); + if (selectedSource.empty()) { + return; + } + + // this subscribe does not share the source subscription + // so that when it is unsubscribed the source will continue + selectedSource->subscribe( + state->out, + collectionLifetime, + // on_next + [state, st](collection_value_type ct) { + auto selectedResult = on_exception( + [&](){return state->selectResult(st, std::move(ct));}, + state->out); + if (selectedResult.empty()) { + return; + } + state->out.on_next(std::move(*selectedResult)); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + //on_completed + [state](){ + if (!state->selectedCollections.empty()) { + auto value = state->selectedCollections.front(); + state->selectedCollections.pop_front(); + state->subscribe_to(value); + } else if (!state->sourceLifetime.is_subscribed()) { + state->out.on_completed(); + } + } + ); + } + composite_subscription sourceLifetime; + composite_subscription collectionLifetime; + std::deque selectedCollections; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, std::forward(scbr))); + + state->sourceLifetime = composite_subscription(); + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.add(state->sourceLifetime); + + auto source = on_exception( + [&](){return state->sourceFilter(state->source);}, + state->out); + if (source.empty()) { + return; + } + + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + source->subscribe( + state->out, + state->sourceLifetime, + // on_next + [state](source_value_type st) { + if (state->collectionLifetime.is_subscribed()) { + state->selectedCollections.push_back(st); + } else { + state->subscribe_to(st); + } + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (!state->collectionLifetime.is_subscribed() && state->selectedCollections.empty()) { + state->out.on_completed(); + } + } + ); + } +}; + +template +class concat_map_factory +{ + typedef typename std::decay::type collection_selector_type; + typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type source_filter_type; + + collection_selector_type selectorCollection; + result_selector_type selectorResult; + source_filter_type sourceFilter; +public: + concat_map_factory(collection_selector_type s, result_selector_type rs, source_filter_type sf) + : selectorCollection(std::move(rs)) + , selectorResult(std::move(s)) + , sourceFilter(std::move(sf)) + { + } + + template + auto operator()(Observable&& source) + -> observable::value_type, concat_map> { + return observable::value_type, concat_map>( + concat_map(std::forward(source), selectorCollection, selectorResult, sourceFilter)); + } +}; + +} + +template +auto concat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) + -> detail::concat_map_factory { + return detail::concat_map_factory(std::forward(s), std::forward(rs), std::forward(sf)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a842f18..0bd9a34 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -330,10 +330,10 @@ public: template struct merge_result { - typedef + typedef observable< - typename this_type::value_type::value_type, - rxo::detail::merge, SourceFilter>> + typename this_type::value_type::value_type, + rxo::detail::merge, SourceFilter>> type; static type make(const this_type* that, SourceFilter sf) { return type(rxo::detail::merge, SourceFilter>(*that, sf)); @@ -363,7 +363,7 @@ public: /// template auto merge(SourceFilter&& sf) const - -> typename std::enable_if::value, + -> typename std::enable_if::value, observable::value_type, rxo::detail::merge>>::type { return observable::value_type, rxo::detail::merge>( rxo::detail::merge(*this, std::forward(sf))); @@ -391,6 +391,28 @@ public: rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } + /// concat_map -> + /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. + /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. + /// + template + auto concat_map(CollectionSelector&& s, ResultSelector&& rs) const + -> observable::value_type, rxo::detail::concat_map> { + return observable::value_type, rxo::detail::concat_map>( + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_observable())); + } + + /// concat_map -> + /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. + /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. + /// + template + auto concat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) const + -> observable::value_type, rxo::detail::concat_map> { + return observable::value_type, rxo::detail::concat_map>( + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); + } + /// multicast -> /// allows connections to the source to be independent of subscriptions /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 7e1439c..e5a5209 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -40,6 +40,7 @@ namespace rxo=operators; #include "operators/rx-map.hpp" #include "operators/rx-merge.hpp" #include "operators/rx-flat_map.hpp" +#include "operators/rx-concat_map.hpp" #include "operators/rx-multicast.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp new file mode 100644 index 0000000..b3c0a95 --- /dev/null +++ b/Rx/v2/test/operators/concat_map.cpp @@ -0,0 +1,148 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +static const int static_tripletCount = 20; + +SCENARIO("concat pythagorian ranges", "[hide][range][concat][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto sc = rxsc::make_immediate(); + //auto sc = rxsc::make_current_thread(); + + int c = 0; + int ct = 0; + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, sc) + .concat_map( + [&c, sc](int z){ + return rxs::range(1, z, 1, sc) + .concat_map( + [&c, sc, z](int x){ + return rxs::range(x, z, 1, sc) + .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}); + triples + .take(tripletCount) + .subscribe( + rxu::apply_to([&ct](int x,int y,int z){++ct;}), + [](std::exception_ptr){abort();}); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + + } + } +} + +SCENARIO("concat_map completes", "[concat_map][map][operators]"){ + GIVEN("two cold observables. one of ints. one of strings."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages ms; + typedef rxn::subscription life; + + typedef m::recorded_type irecord; + auto ion_next = m::on_next; + auto ion_completed = m::on_completed; + auto isubscribe = m::subscribe; + + typedef ms::recorded_type srecord; + auto son_next = ms::on_next; + auto son_completed = ms::on_completed; + auto ssubscribe = ms::subscribe; + + irecord int_messages[] = { + ion_next(100, 4), + ion_next(200, 2), + ion_completed(500) + }; + auto xs = sc.make_cold_observable(int_messages); + + srecord string_messages[] = { + son_next(50, "foo"), + son_next(100, "bar"), + son_next(150, "baz"), + son_next(200, "qux"), + son_completed(250) + }; + auto ys = sc.make_cold_observable(string_messages); + + WHEN("each int is mapped to the strings"){ + + auto res = w.start( + [&]() { + return xs + .concat_map( + [&](int){ + return ys;}, + [](int, std::string s){ + return s;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains strings repeated for each int"){ + srecord items[] = { + son_next(350, "foo"), + son_next(400, "bar"), + son_next(450, "baz"), + son_next(500, "qux"), + son_next(600, "foo"), + son_next(650, "bar"), + son_next(700, "baz"), + son_next(750, "qux"), + son_completed(800) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + life items[] = { + isubscribe(200, 700) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were 2 subscription and unsubscription to the strings"){ + life items[] = { + ssubscribe(300, 550), + ssubscribe(550, 800) + }; + auto required = rxu::to_vector(items); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 921df08..92ab2f2 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 50; +static const int static_tripletCount = 20; SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -89,7 +89,7 @@ SCENARIO("pythagorian ranges", "[hide][range][pythagorian][perf]"){ auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "merge pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; } } @@ -122,7 +122,7 @@ SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagori [&c, sc, z](int x){ return rxs::range(x, z, 1, sc) .filter([&c, z, x](int y){ - ++c; + ++c; if (x*x + y*y == z*z) { return true;} else { @@ -151,7 +151,7 @@ SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagori auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "merge sync pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; } } } diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 52f554a..b4dfa23 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -51,6 +51,7 @@ set(V2_TEST_SOURCES ${V2_TEST_DIR}/subjects/subject.cpp ${V2_TEST_DIR}/subscriptions/subscription.cpp ${V2_TEST_DIR}/operators/flat_map.cpp + ${V2_TEST_DIR}/operators/concat_map.cpp ${V2_TEST_DIR}/operators/map.cpp ) add_executable(rxcppv2_test ${V2_TEST_SOURCES}) -- GitLab From 48e0116b2f249123c17fa27ed6ec236c474735ca Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 30 May 2014 08:29:06 -0700 Subject: [PATCH 296/782] add concat --- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 191 ++++++++++++++++++++ Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 11 +- Rx/v2/src/rxcpp/rx-observable.hpp | 53 ++++++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/concat.cpp | 144 +++++++++++++++ Rx/v2/test/operators/merge.cpp | 2 +- projects/CMake/CMakeLists.txt | 1 + 7 files changed, 397 insertions(+), 6 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-concat.hpp create mode 100644 Rx/v2/test/operators/concat.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp new file mode 100644 index 0000000..c96514a --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -0,0 +1,191 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_CONCAT_HPP) +#define RXCPP_OPERATORS_RX_CONCAT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct concat + : public operator_base::type::value_type::value_type> +{ + typedef concat this_type; + + typedef typename std::decay::type source_type; + typedef typename std::decay::type source_filter_type; + + typedef typename source_type::value_type collection_type; + typedef typename collection_type::value_type value_type; + + struct values + { + values(source_type o, source_filter_type sf) + : source(std::move(o)) + , sourceFilter(std::move(sf)) + { + } + source_type source; + source_filter_type sourceFilter; + }; + values initial; + + concat(source_type o, source_filter_type sf) + : initial(std::move(o), std::move(sf)) + { + } + + template + void on_subscribe(Subscriber&& scbr) { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename std::decay::type output_type; + + struct concat_state_type + : public std::enable_shared_from_this + , public values + { + concat_state_type(values i, output_type oarg) + : values(std::move(i)) + , sourceLifetime(composite_subscription::empty()) + , collectionLifetime(composite_subscription::empty()) + , out(std::move(oarg)) + { + } + + void subscribe_to(collection_type st) + { + auto state = this->shared_from_this(); + + collectionLifetime = composite_subscription(); + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + auto innercstoken = state->out.add(collectionLifetime); + + collectionLifetime.add(make_subscription([state, innercstoken](){ + state->out.remove(innercstoken); + })); + + auto selectedSource = on_exception( + [&](){return state->sourceFilter(st);}, + state->out); + if (selectedSource.empty()) { + return; + } + + // this subscribe does not share the out subscription + // so that when it is unsubscribed the out will continue + selectedSource->subscribe( + state->out, + collectionLifetime, + // on_next + [state, st](value_type ct) { + state->out.on_next(ct); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + //on_completed + [state](){ + if (!state->selectedCollections.empty()) { + auto value = state->selectedCollections.front(); + state->selectedCollections.pop_front(); + state->collectionLifetime.unsubscribe(); + state->subscribe_to(value); + } else if (!state->sourceLifetime.is_subscribed()) { + state->out.on_completed(); + } + } + ); + } + composite_subscription sourceLifetime; + composite_subscription collectionLifetime; + std::deque selectedCollections; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::shared_ptr(new concat_state_type(initial, std::forward(scbr))); + + state->sourceLifetime = composite_subscription(); + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.add(state->sourceLifetime); + + auto source = on_exception( + [&](){return state->sourceFilter(state->source);}, + state->out); + if (source.empty()) { + return; + } + + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + source->subscribe( + state->out, + state->sourceLifetime, + // on_next + [state](collection_type st) { + if (state->collectionLifetime.is_subscribed()) { + state->selectedCollections.push_back(st); + } else if (state->selectedCollections.empty()) { + state->subscribe_to(st); + } + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (!state->collectionLifetime.is_subscribed() && state->selectedCollections.empty()) { + state->out.on_completed(); + } + } + ); + } +}; + +template +class concat_factory +{ + typedef typename std::decay::type source_filter_type; + + source_filter_type sourceFilter; +public: + concat_factory(source_filter_type sf) + : sourceFilter(std::move(sf)) + { + } + + template + auto operator()(Observable&& source) + -> observable::value_type, concat> { + return observable::value_type, concat>( + concat(std::forward(source), sourceFilter)); + } +}; + +} + +template +auto concat(SourceFilter&& sf) + -> detail::concat_factory { + return detail::concat_factory(std::forward(sf)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 9b21368..3ca8f70 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -92,11 +92,11 @@ struct concat_map typedef typename std::decay::type output_type; - struct state_type - : public std::enable_shared_from_this + struct concat_map_state_type + : public std::enable_shared_from_this , public values { - state_type(values i, output_type oarg) + concat_map_state_type(values i, output_type oarg) : values(std::move(i)) , sourceLifetime(composite_subscription::empty()) , collectionLifetime(composite_subscription::empty()) @@ -156,6 +156,7 @@ struct concat_map if (!state->selectedCollections.empty()) { auto value = state->selectedCollections.front(); state->selectedCollections.pop_front(); + state->collectionLifetime.unsubscribe(); state->subscribe_to(value); } else if (!state->sourceLifetime.is_subscribed()) { state->out.on_completed(); @@ -169,7 +170,7 @@ struct concat_map output_type out; }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::forward(scbr))); + auto state = std::shared_ptr(new concat_map_state_type(initial, std::forward(scbr))); state->sourceLifetime = composite_subscription(); @@ -194,7 +195,7 @@ struct concat_map [state](source_value_type st) { if (state->collectionLifetime.is_subscribed()) { state->selectedCollections.push_back(st); - } else { + } else if (state->selectedCollections.empty()) { state->subscribe_to(st); } }, diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 0bd9a34..2134255 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -349,6 +349,7 @@ public: }; /// merge -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// @@ -358,6 +359,7 @@ public: } /// merge -> + /// The source filter can be used to syncronize sources from different contexts. /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// @@ -370,6 +372,7 @@ public: } /// flat_map (AKA SelectMany) -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// @@ -381,6 +384,7 @@ public: } /// flat_map (AKA SelectMany) -> + /// The source filter can be used to syncronize sources from different contexts. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// @@ -391,7 +395,55 @@ public: rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } + template::value> + struct concat_result; + + template + struct concat_result + { + typedef + observable< + typename this_type::value_type::value_type, + rxo::detail::concat, SourceFilter>> + type; + static type make(const this_type* that, SourceFilter sf) { + return type(rxo::detail::concat, SourceFilter>(*that, sf)); + } + }; + template + struct concat_result + { + typedef this_type type; + static type make(const this_type* that, SourceFilter) { + return *that; + } + }; + + /// concat -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// for each item from this observable subscribe to one at a time. in the order received. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + auto concat() const + -> typename concat_result::type { + return concat_result::make(this, identity_observable()); + } + + /// concat -> + /// The source filter can be used to syncronize sources from different contexts. + /// for each item from this observable subscribe to one at a time. in the order received. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + template + auto concat(SourceFilter&& sf) const + -> typename std::enable_if::value, + observable::value_type, rxo::detail::concat>>::type { + return observable::value_type, rxo::detail::concat>( + rxo::detail::concat(*this, std::forward(sf))); + } + /// concat_map -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// @@ -403,6 +455,7 @@ public: } /// concat_map -> + /// The source filter can be used to syncronize sources from different contexts. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index e5a5209..28c26ec 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -40,6 +40,7 @@ namespace rxo=operators; #include "operators/rx-map.hpp" #include "operators/rx-merge.hpp" #include "operators/rx-flat_map.hpp" +#include "operators/rx-concat.hpp" #include "operators/rx-concat_map.hpp" #include "operators/rx-multicast.hpp" #include "operators/rx-publish.hpp" diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp new file mode 100644 index 0000000..0df5e12 --- /dev/null +++ b/Rx/v2/test/operators/concat.cpp @@ -0,0 +1,144 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + + +SCENARIO("concat completes", "[concat][join][operators]"){ + GIVEN("1 hot observable with 3 cold observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages> mo; + typedef rxn::subscription life; + + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + typedef mo::recorded_type orecord; + auto oon_next = mo::on_next; + auto oon_completed = mo::on_completed; + auto osubscribe = mo::subscribe; + + record messages1[] = { + on_next(10, 101), + on_next(20, 102), + on_next(110, 103), + on_next(120, 104), + on_next(210, 105), + on_next(220, 106), + on_completed(230) + }; + auto ys1 = sc.make_cold_observable(messages1); + + record messages2[] = { + on_next(10, 201), + on_next(20, 202), + on_next(30, 203), + on_next(40, 204), + on_completed(50) + }; + auto ys2 = sc.make_cold_observable(messages2); + + record messages3[] = { + on_next(10, 301), + on_next(20, 302), + on_next(30, 303), + on_next(40, 304), + on_next(120, 305), + on_completed(150) + }; + auto ys3 = sc.make_cold_observable(messages3); + + orecord omessages[] = { + oon_next(300, ys1), + oon_next(400, ys2), + oon_next(500, ys3), + oon_completed(600) + }; + auto xs = sc.make_hot_observable(omessages); + + WHEN("each int is merged"){ + + auto res = w.start( + [&]() { + return xs + .concat() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged ints"){ + record items[] = { + on_next(310, 101), + on_next(320, 102), + on_next(410, 103), + on_next(420, 104), + on_next(510, 105), + on_next(520, 106), + on_next(540, 201), + on_next(550, 202), + on_next(560, 203), + on_next(570, 204), + on_next(590, 301), + on_next(600, 302), + on_next(610, 303), + on_next(620, 304), + on_next(700, 305), + on_completed(730) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + life items[] = { + subscribe(200, 600) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys1"){ + life items[] = { + subscribe(300, 530) + }; + auto required = rxu::to_vector(items); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys2"){ + life items[] = { + subscribe(530, 580) + }; + auto required = rxu::to_vector(items); + auto actual = ys2.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys3"){ + life items[] = { + subscribe(580, 730) + }; + auto required = rxu::to_vector(items); + auto actual = ys3.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 1b43592..0ab4486 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -13,7 +13,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -SCENARIO("merge completes", "[flat_map][map][operators]"){ +SCENARIO("merge completes", "[merge][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b4dfa23..1c85d4f 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,6 +42,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/operators/concat.cpp ${V2_TEST_DIR}/operators/merge.cpp ${V2_TEST_DIR}/operators/lift.cpp ${V2_TEST_DIR}/operators/filter.cpp -- GitLab From 890f68ed57b623b10e2f1df4058ced6695599462 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 30 May 2014 16:26:50 -0700 Subject: [PATCH 297/782] add source filter to take_until extracted thread safety out of the take_until operator. --- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 112 ++++++++------------ Rx/v2/src/rxcpp/rx-observable.hpp | 18 +++- 2 files changed, 62 insertions(+), 68 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 6c7389e..3800804 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -13,25 +13,28 @@ namespace operators { namespace detail { -template +template struct take_until : public operator_base { typedef typename std::decay::type source_type; typedef typename std::decay::type trigger_source_type; + typedef typename std::decay::type source_filter_type; struct values { - values(source_type s, trigger_source_type t) + values(source_type s, trigger_source_type t, source_filter_type sf) : source(std::move(s)) , trigger(std::move(t)) + , sourceFilter(std::move(sf)) { } source_type source; trigger_source_type trigger; + source_filter_type sourceFilter; }; values initial; - take_until(source_type s, trigger_source_type t) - : initial(std::move(s), std::move(t)) + take_until(source_type s, trigger_source_type t, source_filter_type sf) + : initial(std::move(s), std::move(t), std::move(sf)) { } @@ -57,16 +60,12 @@ struct take_until : public operator_base take_until_state_type(const values& i, const output_type& oarg) : values(i) , mode_value(mode::taking) - , busy(0) , out(oarg) { out.add(trigger_lifetime); out.add(source_lifetime); } - mutable std::atomic mode_value; - mutable std::atomic busy; - mutable std::mutex finish_lock; - mutable std::exception_ptr exception; + typename mode::type mode_value; composite_subscription trigger_lifetime; composite_subscription source_lifetime; output_type out; @@ -74,65 +73,45 @@ struct take_until : public operator_base // take a copy of the values for each subscription auto state = std::shared_ptr(new take_until_state_type(initial, s)); - struct activity - { - const std::shared_ptr& st; - ~activity() { - if (--st->busy == 0 && st->mode_value > mode::clear) { - // need to finish - // this is the finish owner - std::unique_lock guard(st->finish_lock); - typename mode::type fin = st->mode_value; - auto ex = st->exception; - st->mode_value.exchange(mode::stopped); - guard.unlock(); - if (fin == mode::triggered) { - st->trigger_lifetime.unsubscribe(); - st->source_lifetime.unsubscribe(); - st->out.on_completed(); - } else if (fin == mode::errored) { - st->out.on_error(ex); - } - } - } - explicit activity(const std::shared_ptr& st) - : st(st) - { - ++st->busy; - } + auto trigger = on_exception( + [&](){return state->sourceFilter(state->trigger);}, + state->out); + if (trigger.empty()) { + return; + } - }; + auto source = on_exception( + [&](){return state->sourceFilter(state->source);}, + state->out); + if (source.empty()) { + return; + } - state->trigger.subscribe( + trigger.get().subscribe( // share parts of subscription state->out, // new lifetime state->trigger_lifetime, // on_next [state](const typename trigger_source_type::value_type&) { - activity finisher(state); - std::unique_lock guard(state->finish_lock); if (state->mode_value != mode::taking) {return;} - state->mode_value.exchange(mode::triggered); + state->mode_value = mode::triggered; + state->out.on_completed(); }, // on_error [state](std::exception_ptr e) { - activity finisher(state); - std::unique_lock guard(state->finish_lock); if (state->mode_value != mode::taking) {return;} - state->mode_value.exchange(mode::errored); - state->exception = e; + state->mode_value = mode::errored; + state->out.on_error(e); }, // on_completed [state]() { - activity finisher(state); - std::unique_lock guard(state->finish_lock); if (state->mode_value != mode::taking) {return;} - state->mode_value.exchange(mode::clear); + state->mode_value = mode::clear; } ); - state->source.subscribe( + source.get().subscribe( // split subscription lifetime state->source_lifetime, // on_next @@ -140,51 +119,54 @@ struct take_until : public operator_base // // everything is crafted to minimize the overhead of this function. // - activity finisher(state); if (state->mode_value < mode::triggered) { state->out.on_next(t); } }, // on_error [state](std::exception_ptr e) { - activity finisher(state); - std::unique_lock guard(state->finish_lock); if (state->mode_value > mode::clear) {return;} - state->mode_value.exchange(mode::errored); - state->exception = e; + state->mode_value = mode::errored; + state->out.on_error(e); }, // on_completed [state]() { - activity finisher(state); - std::unique_lock guard(state->finish_lock); if (state->mode_value > mode::clear) {return;} - state->mode_value.exchange(mode::triggered); + state->mode_value = mode::triggered; + state->out.on_completed(); } ); } }; -template +template class take_until_factory { typedef typename std::decay::type trigger_source_type; + typedef typename std::decay::type source_filter_type; + trigger_source_type trigger_source; + source_filter_type source_filter; public: - take_until_factory(trigger_source_type t) : trigger_source(std::move(t)) {} + take_until_factory(trigger_source_type t, source_filter_type sf) + : trigger_source(std::move(t)) + , source_filter(std::move(sf)) + { + } template auto operator()(Observable&& source) - -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type>> { - return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type>>( - take_until::type::value_type, Observable, trigger_source_type>(std::forward(source), trigger_source)); + -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, SourceFilter>> { + return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, SourceFilter>>( + take_until::type::value_type, Observable, trigger_source_type, SourceFilter>(std::forward(source), trigger_source, source_filter)); } }; } -template -auto take_until(TriggerObservable&& t) - -> detail::take_until_factory { - return detail::take_until_factory(std::forward(t)); +template +auto take_until(TriggerObservable&& t, SourceFilter&& sf) + -> detail::take_until_factory { + return detail::take_until_factory(std::forward(t), std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 2134255..5af27df 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -503,13 +503,25 @@ public: } /// take_until -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. /// /// template auto take_until(TriggerSource&& t) const - -> observable> { - return observable>( - rxo::detail::take_until(*this, std::forward(t))); + -> observable> { + return observable>( + rxo::detail::take_until(*this, std::forward(t), identity_observable())); + } + + /// take_until -> + /// The source filter can be used to syncronize sources from different contexts. + /// + /// + template + auto take_until(TriggerSource&& t, SourceFilter&& sf) const + -> observable> { + return observable>( + rxo::detail::take_until(*this, std::forward(t), std::forward(sf))); } }; -- GitLab From ebf03a59277557b14bd82d1bde513498a883e763 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 30 May 2014 22:27:05 -0700 Subject: [PATCH 298/782] Add scan --- Rx/v2/src/rxcpp/operators/rx-scan.hpp | 122 ++++++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 10 +++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/scan.cpp | 76 ++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 5 files changed, 210 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-scan.hpp create mode 100644 Rx/v2/test/operators/scan.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-scan.hpp b/Rx/v2/src/rxcpp/operators/rx-scan.hpp new file mode 100644 index 0000000..3776832 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-scan.hpp @@ -0,0 +1,122 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_SCAN_HPP) +#define RXCPP_OPERATORS_RX_SCAN_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct scan : public operator_base::type> +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type accumulator_type; + typedef typename std::decay::type seed_type; + + struct scan_initial_type + { + scan_initial_type(source_type o, accumulator_type a, seed_type s) + : source(std::move(o)) + , accumulator(std::move(a)) + , seed(s) + { + } + source_type source; + accumulator_type accumulator; + seed_type seed; + }; + scan_initial_type initial; + + template + static auto check(int) -> decltype((*(CP*)nullptr)(*(CS*)nullptr, *(CT*)nullptr)); + template + static void check(...); + + scan(source_type o, accumulator_type a, T s) + : initial(std::move(o), a, s) + { + static_assert(std::is_convertible(0)), seed_type>::value, "scan Accumulator must be a function with the signature Seed(Seed, T)"); + } + template + void on_subscribe(Subscriber o) { + struct scan_state_type + : public scan_initial_type + , public std::enable_shared_from_this + { + scan_state_type(scan_initial_type i, Subscriber scrbr) + : scan_initial_type(i) + , result(scan_initial_type::seed) + , out(std::move(scrbr)) + { + } + seed_type result; + Subscriber out; + }; + auto state = std::make_shared(initial, std::move(o)); + state->source.subscribe( + state->out, + // on_next + [state](T t) { + auto result = on_exception( + [&](){return state->accumulator(state->result, t);}, + state->out); + if (result.empty()) { + return; + } + state->result = result.get(); + state->out.on_next(state->result); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + state->out.on_completed(); + } + ); + } +}; + +template +class scan_factory +{ + typedef typename std::decay::type accumulator_type; + typedef typename std::decay::type seed_type; + + accumulator_type accumulator; + seed_type seed; +public: + scan_factory(accumulator_type a, Seed s) + : accumulator(std::move(a)) + , seed(s) + { + } + template + auto operator()(Observable&& source) + -> observable::type, scan::type::value_type, Observable, Accumulator, Seed>> { + return observable::type, scan::type::value_type, Observable, Accumulator, Seed>>( + scan::type::value_type, Observable, Accumulator, Seed>(std::forward(source), accumulator, seed)); + } +}; + +} + +template +auto scan(Seed s, Accumulator&& a) + -> detail::scan_factory { + return detail::scan_factory(std::forward(a), s); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 5af27df..94b6dd0 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -492,6 +492,16 @@ public: return multicast(rxsub::subject(cs)); } + /// scan -> + /// for each item from this observable use Predicate to combine items into a final value that will be emitted from the new observable that is returned. + /// + template + auto scan(Seed seed, Accumulator&& a) const + -> observable> { + return observable>( + rxo::detail::scan(*this, std::forward(a), seed)); + } + /// take -> /// /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 28c26ec..08bb9dd 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -46,6 +46,7 @@ namespace rxo=operators; #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" #include "operators/rx-connect_forever.hpp" +#include "operators/rx-scan.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" diff --git a/Rx/v2/test/operators/scan.cpp b/Rx/v2/test/operators/scan.cpp new file mode 100644 index 0000000..27ab1c5 --- /dev/null +++ b/Rx/v2/test/operators/scan.cpp @@ -0,0 +1,76 @@ + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("scan some data with seed", "[scan][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + int seed = 1; + + record messages[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto xs = sc.make_hot_observable(messages); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .scan(seed, [](int sum, int x) { + return sum + x; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + record items[] = { + on_next(210, seed + 2), + on_next(220, seed + 2 + 3), + on_next(230, seed + 2 + 3 + 4), + on_next(240, seed + 2 + 3 + 4 + 5), + on_completed(250) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 1c85d4f..ac9099d 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -47,6 +47,7 @@ set(V2_TEST_SOURCES ${V2_TEST_DIR}/operators/lift.cpp ${V2_TEST_DIR}/operators/filter.cpp ${V2_TEST_DIR}/subscriptions/observer.cpp + ${V2_TEST_DIR}/operators/scan.cpp ${V2_TEST_DIR}/operators/take.cpp ${V2_TEST_DIR}/operators/publish.cpp ${V2_TEST_DIR}/subjects/subject.cpp -- GitLab From ece4743c138fd110d5acc018aca7dc93ad56cff3 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 31 May 2014 09:37:00 -0700 Subject: [PATCH 299/782] add iterate and variadic merge --- Rx/v2/src/rxcpp/rx-includes.hpp | 1 + Rx/v2/src/rxcpp/rx-observable.hpp | 76 +++++++++++++---- Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 109 ++++++++++++++++++++++++ Rx/v2/test/operators/merge.cpp | 113 ++++++++++++++++++++++++- 5 files changed, 283 insertions(+), 17 deletions(-) create mode 100644 Rx/v2/src/rxcpp/sources/rx-iterate.hpp diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 75518ab..e26206a 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -81,6 +81,7 @@ #include #include #include +#include #include #include #include diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 94b6dd0..9ecb1b3 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -159,6 +159,42 @@ observable make_observable_dynamic(Source&& s) { return observable(dynamic_observable(std::forward(s))); } +// observable<> has static methods to construct observable sources and adaptors. +// observable<> is not constructable +template<> +class observable +{ + ~observable(); +public: + template + static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable> { + return observable>( + rxs::detail::range(first, last, step, sc)); + } + template + static auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable::value_type, rxs::detail::iterate> { + return observable::value_type, rxs::detail::iterate>( + rxs::detail::iterate(std::move(c), sc)); + } + template + static auto iterate(Value0 v0, ValueN... vn) + -> observable>> { + std::array c = {v0, vn...}; + return observable>>( + rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); + } + template + static auto iterate(Value0 v0, ValueN... vn, rxsc::scheduler sc) + -> observable>> { + std::array c = {v0, vn...}; + return observable>>( + rxs::detail::iterate>(std::move(c), sc)); + } +}; + + template class observable : public observable_base @@ -259,7 +295,7 @@ public: /// /// performs type-forgetting conversion to a new observable /// - observable as_dynamic() { + observable as_dynamic() const { return *this; } @@ -371,6 +407,29 @@ public: rxo::detail::merge(*this, std::forward(sf))); } + /// merge -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// for each item from this observable subscribe. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + template + auto merge(ValueN... vn) const + -> observable { + return observable<>::iterate(this->as_dynamic(), vn.as_dynamic()...).merge(); + } + + /// merge -> + /// The source filter can be used to syncronize sources from different contexts. + /// for each item from this observable subscribe. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + template + auto merge(ValueN... vn, SourceFilter&& sf) const + -> observable { + return observable<>::iterate(this->as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); + } + + /// flat_map (AKA SelectMany) -> /// All sources must be syncronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. @@ -544,21 +603,6 @@ inline bool operator!=(const observable& lhs, const observabl return !(lhs == rhs); } -// observable<> has static methods to construct observable sources and adaptors. -// observable<> is not constructable -template<> -class observable -{ - ~observable(); -public: - template - static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable> { - return observable>( - rxs::detail::range(first, last, step, sc)); - } -}; - } // diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index c504372..a21278c 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -36,5 +36,6 @@ namespace rxs=sources; } #include "sources/rx-range.hpp" +#include "sources/rx-iterate.hpp" #endif diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp new file mode 100644 index 0000000..1156053 --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -0,0 +1,109 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_ITERATE_HPP) +#define RXCPP_SOURCES_RX_ITERATE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct iterate_traits +{ + typedef typename std::decay::type collection_type; + typedef decltype(std::begin(*(collection_type*)nullptr)) iterator_type; + typedef typename std::iterator_traits::value_type value_type; +}; + +template +struct iterate : public source_base::value_type> +{ + typedef iterate this_type; + typedef iterate_traits traits; + + typedef typename traits::collection_type collection_type; + typedef typename traits::iterator_type iterator_type; + + struct iterate_initial_type + { + iterate_initial_type(collection_type c, rxsc::scheduler sc) + : collection(std::move(c)) + , factory(sc) + { + } + collection_type collection; + rxsc::scheduler factory; + }; + iterate_initial_type initial; + + iterate(collection_type c, rxsc::scheduler sc) + : initial(std::move(c), sc) + { + } + template + void on_subscribe(Subscriber o) { + struct iterate_state_type + : public iterate_initial_type + , public std::enable_shared_from_this + { + iterate_state_type(iterate_initial_type i, Subscriber o) + : iterate_initial_type(i) + // creates a worker whose lifetime is the same as this subscription + , controller(iterate_initial_type::factory.create_worker(o.get_subscription())) + , cursor(std::begin(iterate_initial_type::collection)) + , end(std::end(iterate_initial_type::collection)) + , out(o) + { + } + rxsc::worker controller; + iterator_type cursor; + iterator_type end; + Subscriber out; + }; + auto state = std::make_shared(initial, o); + + state->controller.schedule( + [state](const rxsc::schedulable& self){ + if (!state->out.is_subscribed()) { + // terminate loop + return; + } + + if (state->cursor != state->end) { + // send next value + state->out.on_next(*state->cursor); + ++state->cursor; + } + + if (state->cursor == state->end) { + state->out.on_completed(); + // o is unsubscribed + return; + } + + // tail recurse this same action to continue loop + self(); + }); + } +}; + +} + +template +auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable::value_type, detail::iterate> { + return observable::value_type, detail::iterate>( + detail::iterate(std::move(c), sc)); +} + +} + +} + +#endif diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 0ab4486..4354559 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -104,7 +104,7 @@ SCENARIO("merge completes", "[merge][join][operators]"){ REQUIRE(required == actual); } - THEN("there was one subscription and one unsubscription to the ints"){ + THEN("there was one subscription and one unsubscription to the xs"){ life items[] = { subscribe(200, 600) }; @@ -142,3 +142,114 @@ SCENARIO("merge completes", "[merge][join][operators]"){ } } } + +SCENARIO("variadic merge completes", "[merge][join][operators]"){ + GIVEN("1 hot observable with 3 cold observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages> mo; + typedef rxn::subscription life; + + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + typedef mo::recorded_type orecord; + auto oon_next = mo::on_next; + auto oon_completed = mo::on_completed; + auto osubscribe = mo::subscribe; + + record messages1[] = { + on_next(10, 101), + on_next(20, 102), + on_next(110, 103), + on_next(120, 104), + on_next(210, 105), + on_next(220, 106), + on_completed(230) + }; + auto ys1 = sc.make_cold_observable(messages1); + + record messages2[] = { + on_next(10, 201), + on_next(20, 202), + on_next(30, 203), + on_next(40, 204), + on_completed(50) + }; + auto ys2 = sc.make_cold_observable(messages2); + + record messages3[] = { + on_next(10, 301), + on_next(20, 302), + on_next(30, 303), + on_next(40, 304), + on_next(120, 305), + on_completed(150) + }; + auto ys3 = sc.make_cold_observable(messages3); + + WHEN("each int is merged"){ + + auto res = w.start( + [&]() { + return ys1 + .merge(ys2, ys3); + } + ); + + THEN("the output contains merged ints"){ + record items[] = { + on_next(210, 101), + on_next(210, 201), + on_next(210, 301), + on_next(220, 102), + on_next(220, 202), + on_next(220, 302), + on_next(230, 203), + on_next(230, 303), + on_next(240, 204), + on_next(240, 304), + on_next(310, 103), + on_next(320, 104), + on_next(320, 305), + on_next(410, 105), + on_next(420, 106), + on_completed(430) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys1"){ + life items[] = { + subscribe(200, 430) + }; + auto required = rxu::to_vector(items); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys2"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = ys2.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ys3"){ + life items[] = { + subscribe(200, 350) + }; + auto required = rxu::to_vector(items); + auto actual = ys3.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From e5e867e52d34a9a2c82daae794aa578c21905f33 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 13:00:59 -0700 Subject: [PATCH 300/782] filter available overloads --- Rx/v2/src/rxcpp/rx-observable.hpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 9ecb1b3..a1b1fa0 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -401,7 +401,7 @@ public: /// template auto merge(SourceFilter&& sf) const - -> typename std::enable_if::value, + -> typename std::enable_if::value && !is_observable::value, observable::value_type, rxo::detail::merge>>::type { return observable::value_type, rxo::detail::merge>( rxo::detail::merge(*this, std::forward(sf))); @@ -412,10 +412,10 @@ public: /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// - template - auto merge(ValueN... vn) const - -> observable { - return observable<>::iterate(this->as_dynamic(), vn.as_dynamic()...).merge(); + template + auto merge(Value0 v0, ValueN... vn) const + -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { + return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(); } /// merge -> @@ -423,10 +423,10 @@ public: /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// - template - auto merge(ValueN... vn, SourceFilter&& sf) const - -> observable { - return observable<>::iterate(this->as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); + template + auto merge(SourceFilter&& sf, Value0 v0, ValueN... vn) const + -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { + return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); } -- GitLab From d016bf32a047eb30edbade665b86bcd6def39def Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 13:01:08 -0700 Subject: [PATCH 301/782] add all_true --- Rx/v2/src/rxcpp/rx-util.hpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 76b7f9e..e5bdb81 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -55,6 +55,20 @@ struct values_from typedef typename values_from::type type; }; +template +struct all_true; + +template +struct all_true +{ + static const bool value = B0; +}; +template +struct all_true +{ + static const bool value = B0 && all_true::value; +}; + namespace detail { template -- GitLab From be73a796f383181549f7df67a85a30b7eba540a8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 13:01:40 -0700 Subject: [PATCH 302/782] split input and output lifetimes --- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 60ce46a..8d1c1bb 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -53,12 +53,11 @@ class synchronize_observer : public detail::multicast_observer processor.schedule(lifetime, [keepAlive, this](const rxsc::schedulable& self){ try { std::unique_lock guard(lock); - if (!lifetime.is_subscribed() || !destination.is_subscribed()) { + if (!destination.is_subscribed()) { current = mode::Disposed; queue.clear(); guard.unlock(); lifetime.unsubscribe(); - destination.unsubscribe(); return; } if (queue.empty()) { @@ -92,35 +91,35 @@ class synchronize_observer : public detail::multicast_observer if (lifetime.is_subscribed()) { std::unique_lock guard(lock); queue.push_back(notification_type::on_next(std::move(v))); - wake.notify_one(); ensure_processing(guard); } + wake.notify_one(); } void on_error(std::exception_ptr e) const { if (lifetime.is_subscribed()) { std::unique_lock guard(lock); queue.push_back(notification_type::on_error(e)); - wake.notify_one(); ensure_processing(guard); } + wake.notify_one(); } void on_completed() const { if (lifetime.is_subscribed()) { std::unique_lock guard(lock); queue.push_back(notification_type::on_completed()); - wake.notify_one(); ensure_processing(guard); } + wake.notify_one(); } }; std::shared_ptr state; public: - synchronize_observer(rxsc::worker w, composite_subscription cs) - : base_type(cs) + synchronize_observer(rxsc::worker w, composite_subscription dl, composite_subscription il) + : base_type(dl) , state(std::make_shared( - w, cs, make_subscriber(cs, make_observer_dynamic( *static_cast(this) )))) + w, il, make_subscriber(dl, make_observer_dynamic( *static_cast(this) )))) {} template @@ -147,8 +146,8 @@ class synchronize public: explicit synchronize(rxsc::worker w, composite_subscription cs = composite_subscription()) : controller(w) - , lifetime(cs) - , s(w, cs) + , lifetime(composite_subscription()) + , s(w, cs, lifetime) { } -- GitLab From 509f94c2aefd3838db6ec107c2181fd61ea8ecf3 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 13:02:23 -0700 Subject: [PATCH 303/782] add more perf tests --- Rx/v2/test/operators/concat_map.cpp | 65 ++++++++++++++++++++++++++++- Rx/v2/test/operators/flat_map.cpp | 6 +-- Rx/v2/test/operators/merge.cpp | 43 +++++++++++++++++++ 3 files changed, 109 insertions(+), 5 deletions(-) diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index b3c0a95..322d92d 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -12,9 +12,9 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 20; +static const int static_tripletCount = 50; -SCENARIO("concat pythagorian ranges", "[hide][range][concat][pythagorian][perf]"){ +SCENARIO("concat_map pythagorian ranges", "[hide][range][concat_map][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; GIVEN("some ranges"){ WHEN("generating pythagorian triplets"){ @@ -58,6 +58,67 @@ SCENARIO("concat pythagorian ranges", "[hide][range][concat][pythagorian][perf]" } } +SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map][synchronize][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rxsub::synchronize_observable(sc); + + int c = 0; + int ct = 0; + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, sc) + .concat_map( + [&c, sc, so](int z){ + return rxs::range(1, z, 1, sc) + .concat_map( + [&c, sc, z](int x){ + return rxs::range(x, z, 1, sc) + .filter([&c, z, x](int y){ + ++c; + if (x*x + y*y == z*z) { + return true;} + else { + return false;}}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}, + so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}, + so); + triples + .take(tripletCount) + .subscribe( + rxu::apply_to([&ct](int x,int y,int z){ + ++ct;}), + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat sync pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + SCENARIO("concat_map completes", "[concat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 92ab2f2..7b63664 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 20; +static const int static_tripletCount = 50; SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -51,7 +51,7 @@ SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ } } -SCENARIO("pythagorian ranges", "[hide][range][pythagorian][perf]"){ +SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; GIVEN("some ranges"){ WHEN("generating pythagorian triplets"){ @@ -95,7 +95,7 @@ SCENARIO("pythagorian ranges", "[hide][range][pythagorian][perf]"){ } } -SCENARIO("synchronize pythagorian ranges", "[hide][range][synchronize][pythagorian][perf]"){ +SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][synchronize][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; GIVEN("some ranges"){ WHEN("generating pythagorian triplets"){ diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 4354559..77f2033 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -12,6 +12,49 @@ namespace rxt=rxcpp::test; #include "catch.hpp" +const int static_onnextcalls = 1000000; + + +SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("some ranges"){ + WHEN("generating ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rxsub::synchronize_observable(sc); + + int c = 0; + int n = 1; + auto sectionCount = onnextcalls / 3; + auto start = clock::now(); + rxs::range(0, sectionCount - 1, 1, sc) + .merge( + so, + rxs::range(sectionCount, sectionCount * 2 - 1, 1, sc), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, sc)) + .subscribe( + [&c](int x){ + ++c;}, + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "merge sync ranges : " << n << " subscribed, " << c << " emitted, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} SCENARIO("merge completes", "[merge][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ -- GitLab From 6592da5dc3b4ad1136b79a3d39795bc9bd5b2dd4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 13:15:54 -0700 Subject: [PATCH 304/782] add concat overloads --- Rx/v2/src/rxcpp/rx-observable.hpp | 23 +++++++++++++++- Rx/v2/test/operators/concat.cpp | 44 +++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a1b1fa0..ff35040 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -495,12 +495,33 @@ public: /// template auto concat(SourceFilter&& sf) const - -> typename std::enable_if::value, + -> typename std::enable_if::value && !is_observable::value, observable::value_type, rxo::detail::concat>>::type { return observable::value_type, rxo::detail::concat>( rxo::detail::concat(*this, std::forward(sf))); } + /// concat -> + /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// for each item from this observable subscribe to one at a time. in the order received. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + template + auto concat(Value0 v0, ValueN... vn) const + -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { + return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(); + } + + /// concat -> + /// The source filter can be used to syncronize sources from different contexts. + /// for each item from this observable subscribe to one at a time. in the order received. + /// for each item from all of the nested observables deliver from the new observable that is returned. + /// + template + auto concat(SourceFilter&& sf, Value0 v0, ValueN... vn) const + -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { + return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); + } /// concat_map -> /// All sources must be syncronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 0df5e12..ddd6145 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -12,6 +12,50 @@ namespace rxt=rxcpp::test; #include "catch.hpp" +const int static_onnextcalls = 1000000; + + +SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("some ranges"){ + WHEN("generating ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rxsub::synchronize_observable(sc); + + int c = 0; + int n = 1; + auto sectionCount = onnextcalls / 3; + auto start = clock::now(); + rxs::range(0, sectionCount - 1, 1, sc) + .concat( + so, + rxs::range(sectionCount, sectionCount * 2 - 1, 1, sc), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, sc)) + .subscribe( + [&c](int x){ + ++c;}, + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat sync ranges : " << n << " subscribed, " << c << " emitted, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + SCENARIO("concat completes", "[concat][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ -- GitLab From 8634897531a9d984e4ba62ce1b4f799ba5291436 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 17:02:30 -0700 Subject: [PATCH 305/782] add interval --- Rx/v2/src/rxcpp/rx-observable.hpp | 82 ++++++++++++++----------- Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/sources/rx-interval.hpp | 65 ++++++++++++++++++++ Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 15 +++++ Rx/v2/test/subjects/subject.cpp | 27 +++++++- 5 files changed, 151 insertions(+), 39 deletions(-) create mode 100644 Rx/v2/src/rxcpp/sources/rx-interval.hpp diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index ff35040..ed3a8ef 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -159,40 +159,8 @@ observable make_observable_dynamic(Source&& s) { return observable(dynamic_observable(std::forward(s))); } -// observable<> has static methods to construct observable sources and adaptors. -// observable<> is not constructable template<> -class observable -{ - ~observable(); -public: - template - static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable> { - return observable>( - rxs::detail::range(first, last, step, sc)); - } - template - static auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable::value_type, rxs::detail::iterate> { - return observable::value_type, rxs::detail::iterate>( - rxs::detail::iterate(std::move(c), sc)); - } - template - static auto iterate(Value0 v0, ValueN... vn) - -> observable>> { - std::array c = {v0, vn...}; - return observable>>( - rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); - } - template - static auto iterate(Value0 v0, ValueN... vn, rxsc::scheduler sc) - -> observable>> { - std::array c = {v0, vn...}; - return observable>>( - rxs::detail::iterate>(std::move(c), sc)); - } -}; +class observable; template @@ -415,7 +383,7 @@ public: template auto merge(Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { - return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(); + return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(); } /// merge -> @@ -426,7 +394,7 @@ public: template auto merge(SourceFilter&& sf, Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); + return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); } @@ -509,7 +477,7 @@ public: template auto concat(Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { - return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(); + return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(); } /// concat -> @@ -520,7 +488,7 @@ public: template auto concat(SourceFilter&& sf, Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return observable<>::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); + return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); } /// concat_map -> /// All sources must be syncronized! This means that calls across all the subscribers must be serial. @@ -624,6 +592,46 @@ inline bool operator!=(const observable& lhs, const observabl return !(lhs == rhs); } +// observable<> has static methods to construct observable sources and adaptors. +// observable<> is not constructable +template<> +class observable +{ + ~observable(); +public: + template + static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable> { + return observable>( + rxs::detail::range(first, last, step, sc)); + } + static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable { + return observable(rxs::detail::interval(initial, period, sc)); + } + template + static auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable::value_type, rxs::detail::iterate> { + return observable::value_type, rxs::detail::iterate>( + rxs::detail::iterate(std::move(c), sc)); + } + template + static auto iterate(Value0 v0, ValueN... vn) + -> observable>> { + std::array c = {v0, vn...}; + return observable>>( + rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); + } + template + static auto iterate(Value0 v0, ValueN... vn, rxsc::scheduler sc) + -> observable>> { + std::array c = {v0, vn...}; + return observable>>( + rxs::detail::iterate>(std::move(c), sc)); + } +}; + + } // diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index a21278c..6c1f019 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -37,5 +37,6 @@ namespace rxs=sources; #include "sources/rx-range.hpp" #include "sources/rx-iterate.hpp" +#include "sources/rx-interval.hpp" #endif diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp new file mode 100644 index 0000000..235014b --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -0,0 +1,65 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_INTERVAL_HPP) +#define RXCPP_SOURCES_RX_INTERVAL_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +struct interval : public source_base +{ + typedef interval this_type; + + struct interval_initial_type + { + interval_initial_type(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, rxsc::scheduler sc) + : initial(i) + , period(p) + , factory(sc) + { + } + rxsc::scheduler::clock_type::time_point initial; + rxsc::scheduler::clock_type::duration period; + rxsc::scheduler factory; + }; + interval_initial_type initial; + + interval(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, rxsc::scheduler sc) + : initial(i, p, sc) + { + } + template + void on_subscribe(Subscriber o) { + + auto controller = initial.factory.create_worker(o.get_subscription()); + auto counter = std::make_shared(0); + + controller.schedule_periodically( + initial.initial, + initial.period, + [o, counter](const rxsc::schedulable&) { + // send next value + o.on_next(++(*counter)); + }); + } +}; + +} +/* +auto interval(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable { + return observable(detail::interval(i, p, sc)); +} +*/ +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index 1156053..984d217 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -102,6 +102,21 @@ auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) detail::iterate(std::move(c), sc)); } +template +auto iterate(Value0 v0, ValueN... vn) + -> observable>> { + std::array c = {v0, vn...}; + return observable>>( + rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); +} +template +auto iterate(Value0 v0, ValueN... vn, rxsc::scheduler sc) + -> observable>> { + std::array c = {v0, vn...}; + return observable>>( + rxs::detail::iterate>(std::move(c), sc)); +} + } } diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index ea475a6..4894578 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -438,7 +438,6 @@ SCENARIO("range calls subject", "[hide][range][subject][subjects][long][perf]"){ } SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]"){ - const int& onnextcalls = static_onnextcalls; GIVEN("schedule_periodically"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; @@ -461,7 +460,6 @@ SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]") } SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][long][perf]"){ - const int& onnextcalls = static_onnextcalls; GIVEN("schedule_periodically_duration"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; @@ -504,6 +502,31 @@ SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][l } } +SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf]"){ + GIVEN("10 intervals of 1 seconds"){ + WHEN("the period is 1sec and the initial is 2sec"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + auto sc = rxsc::make_current_thread(); + auto start = sc.now() + seconds(2); + auto period = seconds(1); + rx::composite_subscription cs; + rx::observable<>::interval(start, period, sc) + .subscribe( + cs, + [=, &c](long counter){ + auto nsDelta = duration_cast(sc.now() - (start + (period * (counter - 1)))); + c = counter - 1; + std::cout << "interval : period " << counter << ", " << nsDelta.count() << "ms delta from target time" << std::endl; + if (counter == 10) {cs.unsubscribe();} + }, + [](std::exception_ptr){abort();}); + } + } +} + SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ -- GitLab From da337adc55a7f27ef18bb9cff78317adbe4cd7a6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 17:18:15 -0700 Subject: [PATCH 306/782] move interval tests --- Rx/v2/test/sources/interval.cpp | 107 ++++++++++++++++++++++++++++++++ Rx/v2/test/subjects/subject.cpp | 89 -------------------------- projects/CMake/CMakeLists.txt | 1 + 3 files changed, 108 insertions(+), 89 deletions(-) create mode 100644 Rx/v2/test/sources/interval.cpp diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp new file mode 100644 index 0000000..dcfda47 --- /dev/null +++ b/Rx/v2/test/sources/interval.cpp @@ -0,0 +1,107 @@ + +#define RXCPP_SUBJECT_TEST_ASYNC 1 + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + + +SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]"){ + GIVEN("schedule_periodically"){ + WHEN("the period is 1sec and the initial is 2sec"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + auto start = w.now() + seconds(2); + auto period = seconds(1); + w.schedule_periodically(start, period, + [=, &c](rxsc::schedulable scbl){ + auto nsDelta = duration_cast(scbl.now() - (start + (period * c))); + ++c; + std::cout << "schedule_periodically : period " << c << ", " << nsDelta.count() << "ms delta from target time" << std::endl; + if (c == 5) {scbl.unsubscribe();} + }); + } + } +} + +SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][long][perf]"){ + GIVEN("schedule_periodically_duration"){ + WHEN("the period is 1sec and the initial is 2sec"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + + auto schedule_periodically_duration = [w]( + rxsc::current_thread::clock_type::duration initial, + rxsc::current_thread::clock_type::duration period, + rxsc::schedulable activity){ + auto periodic = rxsc::make_schedulable( + activity, + [period, activity](rxsc::schedulable self) { + auto start = clock::now(); + // any recursion requests will be pushed to the scheduler queue + rxsc::recursion r(false); + // call action + activity(r.get_recurse()); + auto finish = clock::now(); + + // schedule next occurance (if the action took longer than 'period' target will be in the past) + self.schedule(period - (finish - start)); + }); + w.schedule(initial, periodic); + }; + + auto start = w.now() + seconds(2); + auto period = seconds(1); + schedule_periodically_duration(seconds(2), period, + rxsc::make_schedulable(w, [=, &c](rxsc::schedulable scbl){ + auto nsDelta = duration_cast(scbl.now() - (start + (period * c))); + ++c; + std::cout << "schedule_periodically_duration : period " << c << ", " << nsDelta.count() << "ms delta from target time" << std::endl; + if (c == 5) {scbl.unsubscribe();} + })); + } + } +} + +SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf]"){ + GIVEN("10 intervals of 1 seconds"){ + WHEN("the period is 1sec and the initial is 2sec"){ + using namespace std::chrono; + typedef steady_clock clock; + + int c = 0; + auto sc = rxsc::make_current_thread(); + auto start = sc.now() + seconds(2); + auto period = seconds(1); + rx::composite_subscription cs; + rx::observable<>::interval(start, period, sc) + .subscribe( + cs, + [=, &c](long counter){ + auto nsDelta = duration_cast(sc.now() - (start + (period * (counter - 1)))); + c = counter - 1; + std::cout << "interval : period " << counter << ", " << nsDelta.count() << "ms delta from target time" << std::endl; + if (counter == 5) {cs.unsubscribe();} + }, + [](std::exception_ptr){abort();}); + } + } +} diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 4894578..9664173 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -437,95 +437,6 @@ SCENARIO("range calls subject", "[hide][range][subject][subjects][long][perf]"){ } } -SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]"){ - GIVEN("schedule_periodically"){ - WHEN("the period is 1sec and the initial is 2sec"){ - using namespace std::chrono; - typedef steady_clock clock; - - int c = 0; - auto sc = rxsc::make_current_thread(); - auto w = sc.create_worker(); - auto start = w.now() + seconds(2); - auto period = seconds(1); - w.schedule_periodically(start, period, - [=, &c](rxsc::schedulable scbl){ - auto nsDelta = duration_cast(scbl.now() - (start + (period * c))); - ++c; - std::cout << "schedule_periodically : period " << c << ", " << nsDelta.count() << "ms delta from target time" << std::endl; - if (c == 9) {scbl.unsubscribe();} - }); - } - } -} - -SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][long][perf]"){ - GIVEN("schedule_periodically_duration"){ - WHEN("the period is 1sec and the initial is 2sec"){ - using namespace std::chrono; - typedef steady_clock clock; - - int c = 0; - auto sc = rxsc::make_current_thread(); - auto w = sc.create_worker(); - - auto schedule_periodically_duration = [w]( - rxsc::current_thread::clock_type::duration initial, - rxsc::current_thread::clock_type::duration period, - rxsc::schedulable activity){ - auto periodic = rxsc::make_schedulable( - activity, - [period, activity](rxsc::schedulable self) { - auto start = clock::now(); - // any recursion requests will be pushed to the scheduler queue - rxsc::recursion r(false); - // call action - activity(r.get_recurse()); - auto finish = clock::now(); - - // schedule next occurance (if the action took longer than 'period' target will be in the past) - self.schedule(period - (finish - start)); - }); - w.schedule(initial, periodic); - }; - - auto start = w.now() + seconds(2); - auto period = seconds(1); - schedule_periodically_duration(seconds(2), period, - rxsc::make_schedulable(w, [=, &c](rxsc::schedulable scbl){ - auto nsDelta = duration_cast(scbl.now() - (start + (period * c))); - ++c; - std::cout << "schedule_periodically_duration : period " << c << ", " << nsDelta.count() << "ms delta from target time" << std::endl; - if (c == 9) {scbl.unsubscribe();} - })); - } - } -} - -SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf]"){ - GIVEN("10 intervals of 1 seconds"){ - WHEN("the period is 1sec and the initial is 2sec"){ - using namespace std::chrono; - typedef steady_clock clock; - - int c = 0; - auto sc = rxsc::make_current_thread(); - auto start = sc.now() + seconds(2); - auto period = seconds(1); - rx::composite_subscription cs; - rx::observable<>::interval(start, period, sc) - .subscribe( - cs, - [=, &c](long counter){ - auto nsDelta = duration_cast(sc.now() - (start + (period * (counter - 1)))); - c = counter - 1; - std::cout << "interval : period " << counter << ", " << nsDelta.count() << "ms delta from target time" << std::endl; - if (counter == 10) {cs.unsubscribe();} - }, - [](std::exception_ptr){abort();}); - } - } -} SCENARIO("subject - infinite source", "[subject][subjects]"){ GIVEN("a subject and an infinite source"){ diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index ac9099d..b90d170 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,6 +42,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/sources/interval.cpp ${V2_TEST_DIR}/operators/concat.cpp ${V2_TEST_DIR}/operators/merge.cpp ${V2_TEST_DIR}/operators/lift.cpp -- GitLab From d505f3977daa97ebfad95b6364340a81a1546c26 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 18:32:58 -0700 Subject: [PATCH 307/782] add defer --- Rx/v2/src/rxcpp/rx-observable.hpp | 6 +++ Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 12 ++++- Rx/v2/src/rxcpp/sources/rx-defer.hpp | 66 +++++++++++++++++++++++ Rx/v2/test/sources/defer.cpp | 75 ++++++++++++++++++++++++++ Rx/v2/test/sources/interval.cpp | 2 - projects/CMake/CMakeLists.txt | 1 + 7 files changed, 160 insertions(+), 3 deletions(-) create mode 100644 Rx/v2/src/rxcpp/sources/rx-defer.hpp create mode 100644 Rx/v2/test/sources/defer.cpp diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index ed3a8ef..2dbcfc1 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -605,6 +605,12 @@ public: return observable>( rxs::detail::range(first, last, step, sc)); } + template + static auto defer(ObservableFactory of) + -> observable::value_type, rxs::detail::defer> { + return observable::value_type, rxs::detail::defer>( + rxs::detail::defer(std::move(of))); + } static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, rxsc::scheduler sc = rxsc::make_current_thread()) -> observable { return observable(rxs::detail::interval(initial, period, sc)); diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index 6c1f019..8831bf8 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -38,5 +38,6 @@ namespace rxs=sources; #include "sources/rx-range.hpp" #include "sources/rx-iterate.hpp" #include "sources/rx-interval.hpp" +#include "sources/rx-defer.hpp" #endif diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 6d3cf6f..9f01ab7 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -82,7 +82,6 @@ public: state->schedule_absolute(state->to_relative(when - now()), scbl); } - void schedule_absolute(absolute when, const schedulable& scbl) const { state->schedule_absolute(when, scbl); } @@ -138,6 +137,11 @@ public: return worker(cs, wi); } + bool is_enabled() const {return state->is_enabled();} + long clock() { + return state->clock(); + } + std::shared_ptr create_test_type_worker_interface() const { std::shared_ptr wi(new test_type_worker(state)); return wi; @@ -406,6 +410,9 @@ public: { } + bool is_enabled() const {return tester->is_enabled();} + long clock() const {return tester->clock();} + void schedule_absolute(long when, const schedulable& a) const { tester->schedule_absolute(when, a); } @@ -501,6 +508,9 @@ public: return test_worker(cs, tester->create_test_type_worker_interface()); } + bool is_enabled() const {return tester->is_enabled();} + long clock() const {return tester->clock();} + template rxt::testable_observable make_hot_observable(std::vector>>> messages) const{ return tester->make_hot_observable(std::move(messages)); diff --git a/Rx/v2/src/rxcpp/sources/rx-defer.hpp b/Rx/v2/src/rxcpp/sources/rx-defer.hpp new file mode 100644 index 0000000..cfeaf4a --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-defer.hpp @@ -0,0 +1,66 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_DEFER_HPP) +#define RXCPP_SOURCES_RX_DEFER_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct defer_traits +{ + typedef typename std::decay::type observable_factory_type; + typedef decltype((*(observable_factory_type*)nullptr)()) collection_type; + typedef typename collection_type::value_type value_type; +}; + +template +struct defer : public source_base::value_type> +{ + typedef defer this_type; + typedef defer_traits traits; + + typedef typename traits::observable_factory_type observable_factory_type; + typedef typename traits::collection_type collection_type; + + observable_factory_type observable_factory; + + defer(observable_factory_type of) + : observable_factory(std::move(of)) + { + } + template + void on_subscribe(Subscriber o) { + + auto selectedCollection = on_exception( + [this](){return this->observable_factory();}, + o); + if (selectedCollection.empty()) { + return; + } + + selectedCollection->subscribe(o); + } +}; + +} + +template +auto defer(ObservableFactory of) + -> observable::value_type, detail::defer> { + return observable::value_type, detail::defer>( + detail::defer(std::move(of))); +} + +} + +} + +#endif diff --git a/Rx/v2/test/sources/defer.cpp b/Rx/v2/test/sources/defer.cpp new file mode 100644 index 0000000..290849b --- /dev/null +++ b/Rx/v2/test/sources/defer.cpp @@ -0,0 +1,75 @@ + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("defer stops on completion", "[defer][operators]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxn::subscription life; + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_error = m::on_error; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + long invoked = 0; + + rxu::detail::maybe> xs; + + WHEN("deferred"){ + + auto res = w.start( + [&]() { + return rx::observable<>::defer( + [&](){ + invoked++; + record messages[] = { + on_next(100, sc.clock()), + on_completed(200) + }; + xs.reset(sc.make_cold_observable(messages)); + return xs.get(); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + record items[] = { + on_next(300, 200L), + on_completed(400) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + life items[] = { + subscribe(200, 400) + }; + auto required = rxu::to_vector(items); + auto actual = xs.get().subscriptions(); + REQUIRE(required == actual); + } + + THEN("defer was called until completed"){ + REQUIRE(1 == invoked); + } + } + } +} diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp index dcfda47..73ce4c8 100644 --- a/Rx/v2/test/sources/interval.cpp +++ b/Rx/v2/test/sources/interval.cpp @@ -1,6 +1,4 @@ -#define RXCPP_SUBJECT_TEST_ASYNC 1 - #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b90d170..0e5dbf5 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,6 +42,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/sources/defer.cpp ${V2_TEST_DIR}/sources/interval.cpp ${V2_TEST_DIR}/operators/concat.cpp ${V2_TEST_DIR}/operators/merge.cpp -- GitLab From 3207f0caf1fa8314d3ef93bace7a7b9aec35807f Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 18:53:50 -0700 Subject: [PATCH 308/782] add never --- Rx/v2/src/rxcpp/rx-observable.hpp | 5 ++++ Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/sources/rx-never.hpp | 36 ++++++++++++++++++++++++++++ 3 files changed, 42 insertions(+) create mode 100644 Rx/v2/src/rxcpp/sources/rx-never.hpp diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 2dbcfc1..7785fd8 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -605,6 +605,11 @@ public: return observable>( rxs::detail::range(first, last, step, sc)); } + template + static auto never() + -> observable> { + return observable>(rxs::detail::never()); + } template static auto defer(ObservableFactory of) -> observable::value_type, rxs::detail::defer> { diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index 8831bf8..967b05d 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -39,5 +39,6 @@ namespace rxs=sources; #include "sources/rx-iterate.hpp" #include "sources/rx-interval.hpp" #include "sources/rx-defer.hpp" +#include "sources/rx-never.hpp" #endif diff --git a/Rx/v2/src/rxcpp/sources/rx-never.hpp b/Rx/v2/src/rxcpp/sources/rx-never.hpp new file mode 100644 index 0000000..2dae656 --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-never.hpp @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_NEVER_HPP) +#define RXCPP_SOURCES_RX_NEVER_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct never : public source_base +{ + template + void on_subscribe(Subscriber o) { + } +}; + +} + +template +auto never() + -> observable> { + return observable>(detail::never()); +} + +} + +} + +#endif -- GitLab From 7dabdfeefc046a6af638a435525571dccd6d1b4e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 19:23:13 -0700 Subject: [PATCH 309/782] add empty, just and from --- Rx/v2/src/rxcpp/rx-observable.hpp | 26 +++++++++++++++++++------- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 18 ++++++++++++++++-- 2 files changed, 35 insertions(+), 9 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 7785fd8..36a470d 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -383,7 +383,7 @@ public: template auto merge(Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { - return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(); + return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(); } /// merge -> @@ -394,7 +394,7 @@ public: template auto merge(SourceFilter&& sf, Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); + return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); } @@ -477,7 +477,7 @@ public: template auto concat(Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { - return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(); + return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(); } /// concat -> @@ -488,7 +488,7 @@ public: template auto concat(SourceFilter&& sf, Value0 v0, ValueN... vn) const -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return rxs::iterate(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); + return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); } /// concat_map -> /// All sources must be syncronized! This means that calls across all the subscribers must be serial. @@ -622,24 +622,36 @@ public: } template static auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable::value_type, rxs::detail::iterate> { + -> typename std::enable_if::value, + observable::value_type, rxs::detail::iterate>>::type { return observable::value_type, rxs::detail::iterate>( rxs::detail::iterate(std::move(c), sc)); } template - static auto iterate(Value0 v0, ValueN... vn) + static auto from(Value0 v0, ValueN... vn) -> observable>> { std::array c = {v0, vn...}; return observable>>( rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); } template - static auto iterate(Value0 v0, ValueN... vn, rxsc::scheduler sc) + static auto from(Value0 v0, ValueN... vn, rxsc::scheduler sc) -> observable>> { std::array c = {v0, vn...}; return observable>>( rxs::detail::iterate>(std::move(c), sc)); } + template + static auto empty(rxsc::scheduler sc = rxsc::make_current_thread()) + -> observable>> { + std::array c; + return observable>>(rxs::detail::iterate>(std::move(c), sc)); + } + template + static auto just(T v, rxsc::scheduler sc = rxsc::make_current_thread()) + -> decltype(from(v)) { + return from(v); + } }; diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index 984d217..bedfe5a 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -13,6 +13,20 @@ namespace sources { namespace detail { +template +struct is_iterable +{ + typedef typename std::decay::type collection_type; + + struct not_void {}; + template + static auto check(int) -> decltype(std::begin(*(CC*)nullptr)); + template + static not_void check(...); + + static const bool value = !std::is_same(0)), not_void>::value; +}; + template struct iterate_traits { @@ -103,14 +117,14 @@ auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) } template -auto iterate(Value0 v0, ValueN... vn) +auto from(Value0 v0, ValueN... vn) -> observable>> { std::array c = {v0, vn...}; return observable>>( rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); } template -auto iterate(Value0 v0, ValueN... vn, rxsc::scheduler sc) +auto from(Value0 v0, ValueN... vn, rxsc::scheduler sc) -> observable>> { std::array c = {v0, vn...}; return observable>>( -- GitLab From 9aeba68fd4b8c6f4a2d2b6df71c56bdb9907f3f7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 1 Jun 2014 20:18:48 -0700 Subject: [PATCH 310/782] add error --- Rx/v2/src/rxcpp/rx-observable.hpp | 45 ++++++------- Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/sources/rx-error.hpp | 87 +++++++++++++++++++++++++ Rx/v2/src/rxcpp/sources/rx-interval.hpp | 1 + 4 files changed, 110 insertions(+), 24 deletions(-) create mode 100644 Rx/v2/src/rxcpp/sources/rx-error.hpp diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 36a470d..86e3f02 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -601,20 +601,18 @@ class observable public: template static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable> { - return observable>( - rxs::detail::range(first, last, step, sc)); + -> decltype(rxs::range(first, last, step, sc)) { + return rxs::range(first, last, step, sc); } template static auto never() - -> observable> { - return observable>(rxs::detail::never()); + -> decltype(rxs::never()) { + return rxs::never(); } template static auto defer(ObservableFactory of) - -> observable::value_type, rxs::detail::defer> { - return observable::value_type, rxs::detail::defer>( - rxs::detail::defer(std::move(of))); + -> decltype(rxs::defer(std::move(of))) { + return rxs::defer(std::move(of)); } static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, rxsc::scheduler sc = rxsc::make_current_thread()) -> observable { @@ -622,35 +620,34 @@ public: } template static auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) - -> typename std::enable_if::value, - observable::value_type, rxs::detail::iterate>>::type { - return observable::value_type, rxs::detail::iterate>( - rxs::detail::iterate(std::move(c), sc)); + -> decltype(rxs::iterate(std::move(c), sc)) { + return rxs::iterate(std::move(c), sc); } template static auto from(Value0 v0, ValueN... vn) - -> observable>> { - std::array c = {v0, vn...}; - return observable>>( - rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); + -> decltype(rxs::from(v0, vn...)) { + return rxs::from(v0, vn...); } template static auto from(Value0 v0, ValueN... vn, rxsc::scheduler sc) - -> observable>> { - std::array c = {v0, vn...}; - return observable>>( - rxs::detail::iterate>(std::move(c), sc)); + -> decltype(rxs::from(v0, vn..., sc)) { + return rxs::from(v0, vn..., sc); } template - static auto empty(rxsc::scheduler sc = rxsc::make_current_thread()) + static auto empty(rxsc::scheduler sc = rxsc::make_immediate()) -> observable>> { std::array c; return observable>>(rxs::detail::iterate>(std::move(c), sc)); } template - static auto just(T v, rxsc::scheduler sc = rxsc::make_current_thread()) - -> decltype(from(v)) { - return from(v); + static auto just(T v, rxsc::scheduler sc = rxsc::make_immediate()) + -> decltype(rxs::from(v, sc)) { + return rxs::from(v, sc); + } + template + static auto error(Exception&& e, rxsc::scheduler sc = rxsc::make_immediate()) + -> observable> { + return rxs::error(std::forward(e), sc); } }; diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index 967b05d..b4205ff 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -40,5 +40,6 @@ namespace rxs=sources; #include "sources/rx-interval.hpp" #include "sources/rx-defer.hpp" #include "sources/rx-never.hpp" +#include "sources/rx-error.hpp" #endif diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp new file mode 100644 index 0000000..1e5e19f --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -0,0 +1,87 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_ERROR_HPP) +#define RXCPP_SOURCES_RX_ERROR_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct error : public source_base +{ + typedef error this_type; + + struct error_initial_type + { + error_initial_type(std::exception_ptr e, rxsc::scheduler sc) + : exception(e) + , factory(sc) + { + } + std::exception_ptr exception; + rxsc::scheduler factory; + }; + error_initial_type initial; + + error(std::exception_ptr e, rxsc::scheduler sc) + : initial(e, sc) + { + } + + template + void on_subscribe(Subscriber o) { + + // creates a worker whose lifetime is the same as this subscription + auto controller = initial.factory.create_worker(o.get_subscription()); + auto exception = initial.exception; + + controller.schedule( + [=](const rxsc::schedulable&){ + if (!o.is_subscribed()) { + // terminate loop + return; + } + + o.on_error(exception); + // o is unsubscribed + }); + } +}; + +struct throw_ptr_tag{}; +struct throw_instance_tag{}; + +template +auto make_error(throw_ptr_tag&&, std::exception_ptr exception, rxsc::scheduler scheduler) + -> observable> { + return observable>(error(std::move(exception), std::move(scheduler))); +} + +template +auto make_error(throw_instance_tag&&, E e, rxsc::scheduler scheduler) + -> observable> { + std::exception_ptr exception; + try {throw e;} catch(...) {exception = std::current_exception();} + return observable>(error(std::move(exception), std::move(scheduler))); +} + +} + +template +auto error(E e, rxsc::scheduler sc = rxsc::make_current_thread()) + -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(sc))) { + return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(sc)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 235014b..8a50256 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -38,6 +38,7 @@ struct interval : public source_base template void on_subscribe(Subscriber o) { + // creates a worker whose lifetime is the same as this subscription auto controller = initial.factory.create_worker(o.get_subscription()); auto counter = std::make_shared(0); -- GitLab From 051c265bd754739d4ddfff4573ffa466e9422fde Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 7 Jun 2014 23:35:03 -0700 Subject: [PATCH 311/782] fix lifetime issue --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index e892828..fbcc331 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -37,7 +37,8 @@ class multicast_observer : public std::enable_shared_from_this { explicit state_type(composite_subscription cs) - : current(mode::Casting) + : generation(0) + , current(mode::Casting) , lifetime(cs) { } @@ -102,6 +103,7 @@ public: { } bool has_observers() const { + std::unique_lock guard(b->state->lock); return b->current_completer && !b->current_completer->observers.empty(); } void add(observer_type o) const { @@ -160,6 +162,7 @@ public: b->state->current = mode::Errored; auto s = b->state->lifetime; auto c = std::move(b->completer); + ++b->state->generation; guard.unlock(); if (c) { for (auto& o : c->observers) { @@ -177,6 +180,7 @@ public: b->state->current = mode::Completed; auto s = b->state->lifetime; auto c = std::move(b->completer); + ++b->state->generation; guard.unlock(); if (c) { for (auto& o : c->observers) { @@ -219,8 +223,9 @@ public: } observable get_observable() const { - return make_observable_dynamic([this](subscriber o){ - this->s.add(std::move(o)); + auto keepAlive = s; + return make_observable_dynamic([=](subscriber o){ + keepAlive.add(std::move(o)); }); } }; -- GitLab From 13c4044274c875a251d86a691e14ef52e648a694 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 7 Jun 2014 23:35:45 -0700 Subject: [PATCH 312/782] perf improvements --- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 2 +- .../rxcpp/operators/rx-connect_forever.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 88 +++++----- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-map.hpp | 119 ++++++-------- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-multicast.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-ref_count.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-take.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 2 +- Rx/v2/src/rxcpp/rx-observable.hpp | 25 ++- Rx/v2/src/rxcpp/rx-scheduler.hpp | 12 +- .../src/rxcpp/schedulers/rx-currentthread.hpp | 36 ++-- Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 4 +- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 17 ++ Rx/v2/src/rxcpp/sources/rx-defer.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-error.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 42 +++-- Rx/v2/src/rxcpp/sources/rx-never.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-range.hpp | 2 +- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 14 +- Rx/v2/test/operators/concat.cpp | 4 +- Rx/v2/test/operators/concat_map.cpp | 4 +- Rx/v2/test/operators/flat_map.cpp | 4 +- Rx/v2/test/operators/merge.cpp | 9 +- Rx/v2/test/subscriptions/subscription.cpp | 154 ++++++++++++++++++ 29 files changed, 368 insertions(+), 198 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index c96514a..fb896e7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -43,7 +43,7 @@ struct concat } template - void on_subscribe(Subscriber&& scbr) { + void on_subscribe(Subscriber&& scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); typedef typename std::decay::type output_type; diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 3ca8f70..7bb0b6d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -87,7 +87,7 @@ struct concat_map } template - void on_subscribe(Subscriber&& scbr) { + void on_subscribe(Subscriber&& scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); typedef typename std::decay::type output_type; diff --git a/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp index 35e000f..b38aa08 100644 --- a/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp @@ -27,7 +27,7 @@ struct connect_forever : public operator_base } template - void on_subscribe(Subscriber&& o) { + void on_subscribe(Subscriber&& o) const { source.subscribe(std::forward(o)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index b220615..ae768c7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -13,50 +13,61 @@ namespace operators { namespace detail { -template -struct filter : public operator_base +template +struct filter { - typedef typename std::decay::type source_type; + typedef typename std::decay::type source_value_type; typedef typename std::decay::type test_type; - source_type source; test_type test; - template - static auto check(int) -> decltype((*(CP*)nullptr)(*(CT*)nullptr)); - template - static void check(...); - filter(source_type o, test_type p) - : source(std::move(o)) - , test(std::move(p)) + filter(test_type t) + : test(std::move(t)) { - static_assert(std::is_convertible(0)), bool>::value, "filter Predicate must be a function with the signature bool(T)"); } + template - void on_subscribe(const Subscriber& o) { - source.subscribe( - o, - // on_next - [this, o](T t) { - bool filtered = false; - try { - filtered = !this->test(t); - } catch(...) { - o.on_error(std::current_exception()); - return; - } - if (!filtered) { - o.on_next(t); - } - }, - // on_error - [o](std::exception_ptr e) { - o.on_error(e); - }, - // on_completed - [o]() { - o.on_completed(); + struct filter_observer : public observer_base + { + typedef filter_observer this_type; + typedef observer_base base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + test_type test; + + filter_observer(dest_type d, test_type t) + : dest(d) + , test(t) + { + } + void on_next(source_value_type v) const { + auto filtered = on_exception([&](){ + return !this->test(v);}, + dest); + if (filtered.empty()) { + return; + } + if (!filtered.get()) { + dest.on_next(v); } - ); + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_completed(); + } + + static subscriber make(dest_type d, test_type t) { + return make_subscriber(d, this_type(d, std::move(t))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(filter_observer::make(std::move(dest), test)) { + return filter_observer::make(std::move(dest), test); } }; @@ -69,9 +80,8 @@ public: filter_factory(test_type p) : predicate(std::move(p)) {} template auto operator()(Observable&& source) - -> observable::type::value_type, filter::type::value_type, Observable, Predicate>> { - return observable::type::value_type, filter::type::value_type, Observable, Predicate>>( - filter::type::value_type, Observable, Predicate>(std::forward(source), std::move(predicate))); + -> decltype(source.lift(filter::type::value_type, test_type>(predicate))) { + return source.lift(filter::type::value_type, test_type>(predicate)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index f120bf7..8943011 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -87,7 +87,7 @@ struct flat_map } template - void on_subscribe(Subscriber&& scbr) { + void on_subscribe(Subscriber&& scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); typedef typename std::decay::type output_type; diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index ae0a581..80748b3 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -62,8 +62,8 @@ struct lift : public operator_base - void on_subscribe(const Subscriber& o) const { - source.on_subscribe(chain(o)); + void on_subscribe(Subscriber o) const { + source.on_subscribe(chain(std::move(o))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 82825ee..eda923a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -13,82 +13,62 @@ namespace operators { namespace detail { -template + +template struct map - : public operator_base { - typedef map this_type; - - typedef typename std::decay::type source_type; + typedef typename std::decay::type source_value_type; typedef typename std::decay::type select_type; + select_type selector; - struct values - { - values(source_type o, select_type s) - : source(std::move(o)) - , select(std::move(s)) - { - } - source_type source; - select_type select; - }; - values initial; - - typedef typename Observable::value_type source_value_type; - - struct tag_not_valid {}; - template - static auto check(int) -> decltype((*(CP*)nullptr)(*(CF*)nullptr)); - template - static tag_not_valid check(...); - - static_assert(!std::is_same(0)), tag_not_valid>::value, "map Selector must be a function with the signature map::value_type(map::source_value_type)"); - - map(source_type o, select_type s) - : initial(std::move(o), std::move(s)) + map(select_type s) + : selector(std::move(s)) { } template - void on_subscribe(const Subscriber& o) { - - typedef Subscriber output_type; - struct state_type - : public std::enable_shared_from_this - , public values + struct map_observer : public observer_base + { + typedef map_observer this_type; + typedef observer_base base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + select_type selector; + + map_observer(dest_type d, select_type s) + : dest(std::move(d)) + , selector(std::move(s)) { - state_type(values i, output_type oarg) - : values(std::move(i)) - , out(std::move(oarg)) - { - } - output_type out; - }; - // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::move(o))); - - state->source.subscribe( - state->out, - // on_next - [state](typename this_type::source_value_type st) { - util::detail::maybe selected; - try { - selected.reset(state->select(st)); - } catch(...) { - state->out.on_error(std::current_exception()); - return; - } - state->out.on_next(std::move(*selected)); - }, - // on_error - [state](std::exception_ptr e) { - state->out.on_error(e); - }, - // on_completed - [state]() { - state->out.on_completed(); + } + void on_next(source_value_type v) const { + auto selected = on_exception( + [&](){ + return this->selector(std::move(v));}, + dest); + if (selected.empty()) { + return; } - ); + dest.on_next(std::move(selected.get())); + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_completed(); + } + + static subscriber make(dest_type d, select_type s) { + auto cs = d.get_subscription(); + return make_subscriber(std::move(cs), this_type(std::move(d), std::move(s))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(map_observer::make(std::move(dest), selector)) { + return map_observer::make(std::move(dest), selector); } }; @@ -98,12 +78,11 @@ class map_factory typedef typename std::decay::type select_type; select_type selector; public: - map_factory(select_type p) : selector(std::move(p)) {} + map_factory(select_type s) : selector(std::move(s)) {} template auto operator()(Observable&& source) - -> observable::value_type, map> { - return observable::value_type, map>( - map(std::forward(source), std::move(selector))); + -> decltype(source.lift(map::type::value_type, select_type>(selector))) { + return source.lift(map::type::value_type, select_type>(selector)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 382e17a..40443b7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -41,7 +41,7 @@ struct merge : public operator_base::type::value } template - void on_subscribe(Subscriber&& scbr) { + void on_subscribe(Subscriber&& scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); typedef typename std::decay::type output_type; diff --git a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp index 7f25071..966bfa3 100644 --- a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp @@ -38,10 +38,10 @@ struct multicast : public operator_base { } template - void on_subscribe(Subscriber&& o) { + void on_subscribe(Subscriber&& o) const { state->subject_value.get_observable().subscribe(std::forward(o)); } - void on_connect(composite_subscription cs) { + void on_connect(composite_subscription cs) const { if (state->connection.empty()) { auto destination = state->subject_value.get_subscriber(); diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp index c289790..9cc3354 100644 --- a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -39,7 +39,7 @@ struct ref_count : public operator_base } template - void on_subscribe(Subscriber&& o) { + void on_subscribe(Subscriber&& o) const { std::unique_lock guard(state->lock); auto needConnect = ++state->subscribers == 1; auto keepAlive = state; diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index 2b2f5b7..46bca55 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -46,7 +46,7 @@ struct take : public operator_base }; template - void on_subscribe(const Subscriber& s) { + void on_subscribe(const Subscriber& s) const { typedef Subscriber output_type; struct state_type diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 3800804..963855e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -50,7 +50,7 @@ struct take_until : public operator_base }; template - void on_subscribe(const Subscriber& s) { + void on_subscribe(const Subscriber& s) const { typedef Subscriber output_type; struct take_until_state_type diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 86e3f02..f4a211b 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -182,11 +182,10 @@ private: friend bool operator==(const observable&, const observable&); template - auto detail_subscribe(Subscriber&& scrbr) const + auto detail_subscribe(Subscriber o) const -> composite_subscription { typedef typename std::decay::type subscriber_type; - subscriber_type o = std::forward(scrbr); static_assert(is_observer::value, "subscribe must be passed an observer"); static_assert(std::is_same::value && std::is_convertible::value, "the value types in the sequence must match or be convertible"); @@ -196,7 +195,7 @@ private: return o.get_subscription(); } - auto safe_subscribe = [=]() { + auto safe_subscribe = [&]() { try { source_operator.on_subscribe(o); } @@ -211,9 +210,9 @@ private: // make sure to let current_thread take ownership of the thread as early as possible. if (rxsc::current_thread::is_schedule_required()) { - auto sc = rxsc::make_current_thread(); + const auto& sc = rxsc::make_current_thread(); sc.create_worker(o.get_subscription()).schedule( - [=](const rxsc::schedulable& scbl) { + [&](const rxsc::schedulable& scbl) { safe_subscribe(); }); } else { @@ -304,18 +303,17 @@ public: /// template auto subscribe(Arg0&& a0, ArgN&&... an) const - -> decltype(detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...))) { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...)); + -> composite_subscription { + return detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...)); } /// filter (AKA Where) -> /// for each item from this observable use Predicate to select which items to emit from the new observable that is returned. /// template - auto filter(Predicate&& p) const - -> observable> { - return observable>( - rxo::detail::filter(*this, std::forward(p))); + auto filter(Predicate p) const + -> decltype(lift(rxo::detail::filter(std::move(p)))) { + return lift(rxo::detail::filter(std::move(p))); } /// map (AKA Select) -> @@ -323,9 +321,8 @@ public: /// template auto map(Selector&& s) const - -> observable::value_type, rxo::detail::map> { - return observable::value_type, rxo::detail::map>( - rxo::detail::map(*this, std::forward(s))); + -> decltype(lift(rxo::detail::map(std::move(s)))) { + return lift(rxo::detail::map(std::move(s))); } template::value> diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index d945e17..5205907 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -464,27 +464,27 @@ public: /// action and worker share lifetime schedulable(worker q, action a) : lifetime(q.get_subscription()) - , controller(q) + , controller(std::move(q)) , activity(std::move(a)) , scoped(false) { } /// action and worker have independent lifetimes schedulable(composite_subscription cs, worker q, action a) - : lifetime(cs) - , controller(q) + : lifetime(std::move(cs)) + , controller(std::move(q)) , activity(std::move(a)) , scoped(true) - , action_scope(q.add(cs)) + , action_scope(controller.add(lifetime)) { } /// inherit lifetimes schedulable(schedulable scbl, worker q, action a) : lifetime(scbl.get_subscription()) - , controller(q) + , controller(std::move(q)) , activity(std::move(a)) , scoped(scbl.scoped) - , action_scope(scbl.scoped ? q.add(scbl.get_subscription()) : weak_subscription()) + , action_scope(scbl.scoped ? controller.add(lifetime) : weak_subscription()) { } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 6c87bdd..06e81ed 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -38,8 +38,11 @@ private: public: - static std::shared_ptr get_worker_interface() { - return !!current_thread_queue() ? current_thread_queue()->w : std::shared_ptr(); + static bool owned() { + return !!current_thread_queue(); + } + static const std::shared_ptr& get_worker_interface() { + return current_thread_queue()->w; } static recursion& get_recursion() { return current_thread_queue()->r; @@ -153,11 +156,9 @@ private: { private: typedef current_thread this_type; - composite_subscription lifetime; current_worker(const this_type&); public: - explicit current_worker(composite_subscription cs) - : lifetime(std::move(cs)) + current_worker() { } virtual ~current_worker() @@ -178,11 +179,11 @@ private: } { - auto wi = queue::get_worker_interface(); // check ownership - if (!!wi) { + if (queue::owned()) { // already has an owner - delegate - return worker(lifetime, wi).schedule(when, scbl); + queue::get_worker_interface()->schedule(when, scbl); + return; } // take ownership @@ -193,9 +194,14 @@ private: queue::destroy(); }); - queue::push(queue::item_type(when, scbl)); - const auto& recursor = queue::get_recursion().get_recurse(); + std::this_thread::sleep_until(when); + if (scbl.is_subscribed()) { + scbl(recursor); + } + if (queue::empty()) { + return; + } // loop until queue is empty for ( @@ -218,15 +224,18 @@ private: } }; + std::shared_ptr wi; + public: current_thread() + : wi(new current_worker()) { } virtual ~current_thread() { } - static bool is_schedule_required() { return !queue::get_worker_interface(); } + static bool is_schedule_required() { return !queue::owned(); } inline bool is_tail_recursion_allowed() const { return queue::empty(); @@ -237,12 +246,11 @@ public: } virtual worker create_worker(composite_subscription cs) const { - std::shared_ptr wi(new current_worker(cs)); - return worker(cs, wi); + return worker(std::move(cs), wi); } }; -inline scheduler make_current_thread() { +inline const scheduler& make_current_thread() { static auto ct = make_scheduler(); return ct; } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp index 1710fb7..73592ec 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -68,11 +68,11 @@ public: } virtual worker create_worker(composite_subscription cs) const { - return worker(cs, wi); + return worker(std::move(cs), wi); } }; -inline scheduler make_immediate() { +inline const scheduler& make_immediate() { static auto i = make_scheduler(); return i; } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp index 89a0a12..4144053 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -23,6 +23,9 @@ private: { private: typedef new_worker this_type; + + typedef detail::action_queue queue; + new_worker(const this_type&); struct new_worker_state : public std::enable_shared_from_this @@ -65,6 +68,12 @@ private: virtual ~new_worker() { } + + explicit new_worker(std::shared_ptr ws) + : state(ws) + { + } + new_worker(composite_subscription cs, thread_factory& tf) : state(std::make_shared(cs)) { @@ -75,6 +84,14 @@ private: }); state->worker = tf([keepAlive](){ + + // take ownership + queue::ensure(std::make_shared(keepAlive)); + // release ownership + RXCPP_UNWIND_AUTO([]{ + queue::destroy(); + }); + for(;;) { std::unique_lock guard(keepAlive->lock); if (keepAlive->queue.empty()) { diff --git a/Rx/v2/src/rxcpp/sources/rx-defer.hpp b/Rx/v2/src/rxcpp/sources/rx-defer.hpp index cfeaf4a..5aef7ef 100644 --- a/Rx/v2/src/rxcpp/sources/rx-defer.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-defer.hpp @@ -37,7 +37,7 @@ struct defer : public source_base::valu { } template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { auto selectedCollection = on_exception( [this](){return this->observable_factory();}, diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index 1e5e19f..aa8d89c 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -36,7 +36,7 @@ struct error : public source_base } template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { // creates a worker whose lifetime is the same as this subscription auto controller = initial.factory.create_worker(o.get_subscription()); diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 8a50256..5b77e90 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -36,7 +36,7 @@ struct interval : public source_base { } template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { // creates a worker whose lifetime is the same as this subscription auto controller = initial.factory.create_worker(o.get_subscription()); diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index bedfe5a..dc5be36 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -57,46 +57,52 @@ struct iterate : public source_base::value_t iterate_initial_type initial; iterate(collection_type c, rxsc::scheduler sc) - : initial(std::move(c), sc) + : initial(std::move(c), std::move(sc)) { } template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { struct iterate_state_type : public iterate_initial_type - , public std::enable_shared_from_this { - iterate_state_type(iterate_initial_type i, Subscriber o) + iterate_state_type(const iterate_initial_type& i, Subscriber o) : iterate_initial_type(i) - // creates a worker whose lifetime is the same as this subscription - , controller(iterate_initial_type::factory.create_worker(o.get_subscription())) , cursor(std::begin(iterate_initial_type::collection)) , end(std::end(iterate_initial_type::collection)) - , out(o) + , out(std::move(o)) { } - rxsc::worker controller; - iterator_type cursor; + iterate_state_type(const iterate_state_type& o) + : iterate_initial_type(o) + , cursor(std::begin(iterate_initial_type::collection)) + , end(std::end(iterate_initial_type::collection)) + , out(std::move(o.out)) // since lambda capture does not yet support move + { + } + mutable iterator_type cursor; iterator_type end; - Subscriber out; + mutable Subscriber out; }; - auto state = std::make_shared(initial, o); + iterate_state_type state(initial, std::move(o)); + + // creates a worker whose lifetime is the same as this subscription + auto controller = state.factory.create_worker(state.out.get_subscription()); - state->controller.schedule( + controller.schedule( [state](const rxsc::schedulable& self){ - if (!state->out.is_subscribed()) { + if (!state.out.is_subscribed()) { // terminate loop return; } - if (state->cursor != state->end) { + if (state.cursor != state.end) { // send next value - state->out.on_next(*state->cursor); - ++state->cursor; + state.out.on_next(*state.cursor); + ++state.cursor; } - if (state->cursor == state->end) { - state->out.on_completed(); + if (state.cursor == state.end) { + state.out.on_completed(); // o is unsubscribed return; } diff --git a/Rx/v2/src/rxcpp/sources/rx-never.hpp b/Rx/v2/src/rxcpp/sources/rx-never.hpp index 2dae656..22b6c24 100644 --- a/Rx/v2/src/rxcpp/sources/rx-never.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-never.hpp @@ -17,7 +17,7 @@ template struct never : public source_base { template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { } }; diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index 9edc451..c8c4ae0 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -33,7 +33,7 @@ struct range : public source_base init.sc = sc; } template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { auto state = std::make_shared(init); // creates a worker whose lifetime is the same as this subscription state->w = state->sc.create_worker(o.get_subscription()); diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 8d1c1bb..f7f9b78 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -79,10 +79,10 @@ class synchronize_observer : public detail::multicast_observer } synchronize_observer_state(rxsc::worker w, composite_subscription cs, subscriber scbr) - : lifetime(cs) - , processor(w) + : lifetime(std::move(cs)) + , processor(std::move(w)) , current(mode::Empty) - , destination(scbr) + , destination(std::move(scbr)) { } @@ -119,7 +119,7 @@ public: synchronize_observer(rxsc::worker w, composite_subscription dl, composite_subscription il) : base_type(dl) , state(std::make_shared( - w, il, make_subscriber(dl, make_observer_dynamic( *static_cast(this) )))) + std::move(w), std::move(il), make_subscriber(dl, make_observer_dynamic( *static_cast(this) )))) {} template @@ -139,15 +139,13 @@ public: template class synchronize { - rxsc::worker controller; composite_subscription lifetime; detail::synchronize_observer s; public: explicit synchronize(rxsc::worker w, composite_subscription cs = composite_subscription()) - : controller(w) - , lifetime(composite_subscription()) - , s(w, cs, lifetime) + : lifetime(composite_subscription()) + , s(std::move(w), std::move(cs), lifetime) { } diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index ddd6145..864166c 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -29,7 +29,7 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" //auto sc = rxsc::make_new_thread(); auto so = rxsub::synchronize_observable(sc); - int c = 0; + std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); @@ -46,7 +46,7 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" wake.notify_one();}); std::unique_lock guard(lock); - wake.wait(guard); + wake.wait(guard, [&](){return c == onnextcalls;}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 322d92d..058a645 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -73,7 +73,7 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] auto so = rxsub::synchronize_observable(sc); int c = 0; - int ct = 0; + std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -109,7 +109,7 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] wake.notify_one();}); std::unique_lock guard(lock); - wake.wait(guard); + wake.wait(guard, [&](){return ct == tripletCount;}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 7b63664..cb9b2a0 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -110,7 +110,7 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn auto so = rxsub::synchronize_observable(sc); int c = 0; - int ct = 0; + std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -146,7 +146,7 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn wake.notify_one();}); std::unique_lock guard(lock); - wake.wait(guard); + wake.wait(guard, [&](){return ct == tripletCount;}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 77f2033..931d26f 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -29,24 +29,25 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ //auto sc = rxsc::make_new_thread(); auto so = rxsub::synchronize_observable(sc); - int c = 0; + std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); rxs::range(0, sectionCount - 1, 1, sc) .merge( so, - rxs::range(sectionCount, sectionCount * 2 - 1, 1, sc), + rxs::range(sectionCount, (sectionCount * 2) - 1, 1, sc), rxs::range(sectionCount * 2, onnextcalls - 1, 1, sc)) .subscribe( [&c](int x){ ++c;}, [](std::exception_ptr){abort();}, [&](){ - wake.notify_one();}); + wake.notify_one(); + }); std::unique_lock guard(lock); - wake.wait(guard); + wake.wait(guard, [&](){return c == onnextcalls;}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index f2959f7..1c040ba 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -1,8 +1,162 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; +namespace rxs=rx::rxs; +namespace rxsc=rx::rxsc; #include "catch.hpp" +static const int static_subscriptions = 500000; + +SCENARIO("for loop subscribes", "[hide][for][just][subscribe][long][perf]"){ + const int& subscriptions = static_subscriptions; + GIVEN("a for loop"){ + WHEN("subscribe 10 million times"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + int runs = 10; + + auto loop = [&](const rxsc::schedulable& self) { + int c = 0; + int n = 1; + auto start = clock::now(); + for (int i = 0; i < subscriptions; i++) { + rx::observable<>::just(1) + .map([](int i) { + return (std::stringstream() << i).str(); + //return std::string("1"); + }) + .map([](const std::string& s) { + int i; + std::stringstream(s) >> i; + return i; + //return 1; + }) + .subscribe([&](int i){ + ++c; + }); + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "loop subscribe : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + + if (--runs > 0) { + self(); + } + }; + + w.schedule(loop); + } + } +} + +SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf]"){ + GIVEN("range"){ + WHEN("syncronized"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + + auto el = rxsc::make_event_loop(); + + int runs = 10; + + auto loop = [&](const rxsc::schedulable& self) { + std::atomic c(0); + int n = 1; + auto liftrequirecompletion = [&](rx::subscriber dest){ + auto completionstate = std::make_shared>>(0, std::move(dest)); + completionstate->second.add([=](){ + if (completionstate->first != 500) { + abort(); + } + }); + // VS2013 deduction issue requires dynamic (type-forgetting) + return rx::make_subscriber( + completionstate->second, + rx::make_observer_dynamic( + [=](int n){ + ++completionstate->first; + completionstate->second.on_next(n); + }, + [=](std::exception_ptr e){ + abort(); + completionstate->second.on_error(e); + }, + [=](){ + if (completionstate->first != 500) { + abort(); + } + completionstate->second.on_completed(); + })); + }; + auto start = clock::now(); + auto ew = el.create_worker(); + std::atomic v(0); + auto s0 = rxs::range(0, 499, 1, el) + .lift(liftrequirecompletion) + .as_dynamic() + .synchronize(ew) + .ref_count() + .lift(liftrequirecompletion) + .subscribe( + rx::make_observer_dynamic( + [&](int i){ + ++v; + }, + [&](){ + ++c; + })); + auto s1 = rxs::range(500, 999, 1, el) + .lift(liftrequirecompletion) + .as_dynamic() + .synchronize(ew) + .ref_count() + .lift(liftrequirecompletion) + .subscribe( + rx::make_observer_dynamic( + [&](int i){ + ++v; + }, + [&](){ + ++c; + })); + auto s2 = rxs::range(1000, 1499, 1, el) + .lift(liftrequirecompletion) + .as_dynamic() + .synchronize(ew) + .ref_count() + .lift(liftrequirecompletion) + .subscribe( + rx::make_observer_dynamic( + [&](int i){ + ++v; + }, + [&](){ + ++c; + })); + while(v != 1500 || c != 3); + s0.unsubscribe(); + s1.unsubscribe(); + s2.unsubscribe(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "range syncronize : " << n << " subscribed, " << v << " on_next calls, " << msElapsed.count() << "ms elapsed, " << v / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + + if (--runs > 0) { + self(); + } + }; + + w.schedule(loop); + } + } +} + SCENARIO("subscription traits", "[subscription][traits]"){ GIVEN("given some subscription types"){ auto empty = [](){}; -- GitLab From ad9bfc24a045559e521d6d2eafde22813e449466 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 4 Jun 2014 16:43:41 -0700 Subject: [PATCH 313/782] remove regulator, add coordination --- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 63 +++--- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 70 ++++--- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 70 ++++--- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 62 +++--- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 58 +++--- Rx/v2/src/rxcpp/rx-coordination.hpp | 158 +++++++++++++++ Rx/v2/src/rxcpp/rx-includes.hpp | 2 +- Rx/v2/src/rxcpp/rx-observable.hpp | 171 ++++++++-------- Rx/v2/src/rxcpp/rx-regulator.hpp | 101 ---------- Rx/v2/src/rxcpp/rx-scheduler.hpp | 6 + Rx/v2/src/rxcpp/rx-subscriber.hpp | 196 +++---------------- Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp | 53 +++++ Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 93 +++++---- Rx/v2/test/operators/concat.cpp | 2 +- Rx/v2/test/operators/concat_map.cpp | 4 +- Rx/v2/test/operators/flat_map.cpp | 4 +- Rx/v2/test/operators/merge.cpp | 2 +- Rx/v2/test/sources/defer.cpp | 6 + Rx/v2/test/subscriptions/observer.cpp | 6 +- 19 files changed, 598 insertions(+), 529 deletions(-) create mode 100644 Rx/v2/src/rxcpp/rx-coordination.hpp delete mode 100644 Rx/v2/src/rxcpp/rx-regulator.hpp create mode 100644 Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index fb896e7..9280fb4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -13,49 +13,52 @@ namespace operators { namespace detail { -template +template struct concat : public operator_base::type::value_type::value_type> { - typedef concat this_type; + typedef concat this_type; typedef typename std::decay::type source_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; + + typedef typename coordination_type::coordinator_type coordinator_type; typedef typename source_type::value_type collection_type; typedef typename collection_type::value_type value_type; struct values { - values(source_type o, source_filter_type sf) + values(source_type o, coordination_type sf) : source(std::move(o)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } source_type source; - source_filter_type sourceFilter; + coordination_type coordination; }; values initial; - concat(source_type o, source_filter_type sf) + concat(source_type o, coordination_type sf) : initial(std::move(o), std::move(sf)) { } template - void on_subscribe(Subscriber&& scbr) const { + void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename std::decay::type output_type; + typedef typename coordinator_type::template get::type output_type; struct concat_state_type : public std::enable_shared_from_this , public values { - concat_state_type(values i, output_type oarg) + concat_state_type(values i, coordinator_type coor, output_type oarg) : values(std::move(i)) , sourceLifetime(composite_subscription::empty()) , collectionLifetime(composite_subscription::empty()) + , coordinator(std::move(coor)) , out(std::move(oarg)) { } @@ -75,7 +78,7 @@ struct concat })); auto selectedSource = on_exception( - [&](){return state->sourceFilter(st);}, + [&](){return state->coordinator(std::move(st));}, state->out); if (selectedSource.empty()) { return; @@ -110,10 +113,20 @@ struct concat composite_subscription sourceLifetime; composite_subscription collectionLifetime; std::deque selectedCollections; + coordinator_type coordinator; output_type out; }; + + auto coordinator = initial.coordination.create_coordinator(); + auto selectedDest = on_exception( + [&](){return coordinator(scbr);}, + scbr); + if (selectedDest.empty()) { + return; + } + // take a copy of the values for each subscription - auto state = std::shared_ptr(new concat_state_type(initial, std::forward(scbr))); + auto state = std::shared_ptr(new concat_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); state->sourceLifetime = composite_subscription(); @@ -122,7 +135,7 @@ struct concat state->out.add(state->sourceLifetime); auto source = on_exception( - [&](){return state->sourceFilter(state->source);}, + [&](){return state->coordinator(state->source);}, state->out); if (source.empty()) { return; @@ -156,32 +169,32 @@ struct concat } }; -template +template class concat_factory { - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; - source_filter_type sourceFilter; + coordination_type coordination; public: - concat_factory(source_filter_type sf) - : sourceFilter(std::move(sf)) + concat_factory(coordination_type sf) + : coordination(std::move(sf)) { } template auto operator()(Observable&& source) - -> observable::value_type, concat> { - return observable::value_type, concat>( - concat(std::forward(source), sourceFilter)); + -> observable::value_type, concat> { + return observable::value_type, concat>( + concat(std::forward(source), coordination)); } }; } -template -auto concat(SourceFilter&& sf) - -> detail::concat_factory { - return detail::concat_factory(std::forward(sf)); +template +auto concat(Coordination&& sf) + -> detail::concat_factory { + return detail::concat_factory(std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 7bb0b6d..9f15d80 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -13,12 +13,12 @@ namespace operators { namespace detail { -template +template struct concat_traits { typedef typename std::decay::type source_type; typedef typename std::decay::type collection_selector_type; typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; typedef typename source_type::value_type source_value_type; @@ -48,12 +48,12 @@ struct concat_traits { typedef decltype((*(result_selector_type*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; }; -template +template struct concat_map - : public operator_base::value_type> + : public operator_base::value_type> { - typedef concat_map this_type; - typedef concat_traits traits; + typedef concat_map this_type; + typedef concat_traits traits; typedef typename traits::source_type source_type; typedef typename traits::collection_selector_type collection_selector_type; @@ -63,43 +63,45 @@ struct concat_map typedef typename traits::collection_type collection_type; typedef typename traits::collection_value_type collection_value_type; - typedef typename traits::source_filter_type source_filter_type; + typedef typename traits::coordination_type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; struct values { - values(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + values(source_type o, collection_selector_type s, result_selector_type rs, coordination_type sf) : source(std::move(o)) , selectCollection(std::move(s)) , selectResult(std::move(rs)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } source_type source; collection_selector_type selectCollection; result_selector_type selectResult; - source_filter_type sourceFilter; + coordination_type coordination; }; values initial; - concat_map(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + concat_map(source_type o, collection_selector_type s, result_selector_type rs, coordination_type sf) : initial(std::move(o), std::move(s), std::move(rs), std::move(sf)) { } template - void on_subscribe(Subscriber&& scbr) const { + void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename std::decay::type output_type; + typedef typename coordinator_type::template get::type output_type; struct concat_map_state_type : public std::enable_shared_from_this , public values { - concat_map_state_type(values i, output_type oarg) + concat_map_state_type(values i, coordinator_type coor, output_type oarg) : values(std::move(i)) , sourceLifetime(composite_subscription::empty()) , collectionLifetime(composite_subscription::empty()) + , coordinator(std::move(coor)) , out(std::move(oarg)) { } @@ -126,7 +128,7 @@ struct concat_map })); auto selectedSource = on_exception( - [&](){return state->sourceFilter(selectedCollection.get());}, + [&](){return state->coordinator(selectedCollection.get());}, state->out); if (selectedSource.empty()) { return; @@ -167,10 +169,20 @@ struct concat_map composite_subscription sourceLifetime; composite_subscription collectionLifetime; std::deque selectedCollections; + coordinator_type coordinator; output_type out; }; + + auto coordinator = initial.coordination.create_coordinator(); + auto selectedDest = on_exception( + [&](){return coordinator(scbr);}, + scbr); + if (selectedDest.empty()) { + return; + } + // take a copy of the values for each subscription - auto state = std::shared_ptr(new concat_map_state_type(initial, std::forward(scbr))); + auto state = std::shared_ptr(new concat_map_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); state->sourceLifetime = composite_subscription(); @@ -179,7 +191,7 @@ struct concat_map state->out.add(state->sourceLifetime); auto source = on_exception( - [&](){return state->sourceFilter(state->source);}, + [&](){return state->coordinator(state->source);}, state->out); if (source.empty()) { return; @@ -213,38 +225,38 @@ struct concat_map } }; -template +template class concat_map_factory { typedef typename std::decay::type collection_selector_type; typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; collection_selector_type selectorCollection; result_selector_type selectorResult; - source_filter_type sourceFilter; + coordination_type coordination; public: - concat_map_factory(collection_selector_type s, result_selector_type rs, source_filter_type sf) + concat_map_factory(collection_selector_type s, result_selector_type rs, coordination_type sf) : selectorCollection(std::move(rs)) , selectorResult(std::move(s)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } template auto operator()(Observable&& source) - -> observable::value_type, concat_map> { - return observable::value_type, concat_map>( - concat_map(std::forward(source), selectorCollection, selectorResult, sourceFilter)); + -> observable::value_type, concat_map> { + return observable::value_type, concat_map>( + concat_map(std::forward(source), selectorCollection, selectorResult, coordination)); } }; } -template -auto concat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) - -> detail::concat_map_factory { - return detail::concat_map_factory(std::forward(s), std::forward(rs), std::forward(sf)); +template +auto concat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) + -> detail::concat_map_factory { + return detail::concat_map_factory(std::forward(s), std::forward(rs), std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 8943011..e664399 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -13,12 +13,12 @@ namespace operators { namespace detail { -template +template struct flat_map_traits { typedef typename std::decay::type source_type; typedef typename std::decay::type collection_selector_type; typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; typedef typename source_type::value_type source_value_type; @@ -48,12 +48,12 @@ struct flat_map_traits { typedef decltype((*(result_selector_type*)nullptr)(*(source_value_type*)nullptr, *(collection_value_type*)nullptr)) value_type; }; -template +template struct flat_map - : public operator_base::value_type> + : public operator_base::value_type> { - typedef flat_map this_type; - typedef flat_map_traits traits; + typedef flat_map this_type; + typedef flat_map_traits traits; typedef typename traits::source_type source_type; typedef typename traits::collection_selector_type collection_selector_type; @@ -63,52 +63,64 @@ struct flat_map typedef typename traits::collection_type collection_type; typedef typename traits::collection_value_type collection_value_type; - typedef typename traits::source_filter_type source_filter_type; + typedef typename traits::coordination_type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; struct values { - values(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + values(source_type o, collection_selector_type s, result_selector_type rs, coordination_type sf) : source(std::move(o)) , selectCollection(std::move(s)) , selectResult(std::move(rs)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } source_type source; collection_selector_type selectCollection; result_selector_type selectResult; - source_filter_type sourceFilter; + coordination_type coordination; }; values initial; - flat_map(source_type o, collection_selector_type s, result_selector_type rs, source_filter_type sf) + flat_map(source_type o, collection_selector_type s, result_selector_type rs, coordination_type sf) : initial(std::move(o), std::move(s), std::move(rs), std::move(sf)) { } template - void on_subscribe(Subscriber&& scbr) const { + void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename std::decay::type output_type; + typedef typename coordinator_type::template get::type output_type; struct state_type : public std::enable_shared_from_this , public values { - state_type(values i, output_type oarg) + state_type(values i, coordinator_type coor, output_type oarg) : values(std::move(i)) , pendingCompletions(0) + , coordinator(std::move(coor)) , out(std::move(oarg)) { } // on_completed on the output must wait until all the // subscriptions have received on_completed int pendingCompletions; + coordinator_type coordinator; output_type out; }; + + auto coordinator = initial.coordination.create_coordinator(); + auto selectedDest = on_exception( + [&](){return coordinator(scbr);}, + scbr); + if (selectedDest.empty()) { + return; + } + // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::forward(scbr))); + auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); composite_subscription outercs; @@ -117,7 +129,7 @@ struct flat_map state->out.add(outercs); auto source = on_exception( - [&](){return state->sourceFilter(state->source);}, + [&](){return state->coordinator(state->source);}, state->out); if (source.empty()) { return; @@ -150,7 +162,7 @@ struct flat_map })); auto selectedSource = on_exception( - [&](){return state->sourceFilter(selectedCollection.get());}, + [&](){return state->coordinator(selectedCollection.get());}, state->out); if (selectedSource.empty()) { return; @@ -198,38 +210,38 @@ struct flat_map } }; -template +template class flat_map_factory { typedef typename std::decay::type collection_selector_type; typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; collection_selector_type selectorCollection; result_selector_type selectorResult; - source_filter_type sourceFilter; + coordination_type coordination; public: - flat_map_factory(collection_selector_type s, result_selector_type rs, source_filter_type sf) + flat_map_factory(collection_selector_type s, result_selector_type rs, coordination_type sf) : selectorCollection(std::move(rs)) , selectorResult(std::move(s)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } template auto operator()(Observable&& source) - -> observable::value_type, flat_map> { - return observable::value_type, flat_map>( - flat_map(std::forward(source), selectorCollection, selectorResult, sourceFilter)); + -> observable::value_type, flat_map> { + return observable::value_type, flat_map>( + flat_map(std::forward(source), selectorCollection, selectorResult, coordination)); } }; } -template -auto flat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) - -> detail::flat_map_factory { - return detail::flat_map_factory(std::forward(s), std::forward(rs), std::forward(sf)); +template +auto flat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) + -> detail::flat_map_factory { + return detail::flat_map_factory(std::forward(s), std::forward(rs), std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 40443b7..e577777 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -13,56 +13,68 @@ namespace operators { namespace detail { -template +template struct merge : public operator_base::type::value_type::value_type> { - typedef merge this_type; + typedef merge this_type; typedef typename std::decay::type source_type; typedef typename source_type::value_type source_value_type; typedef typename source_value_type::value_type value_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; struct values { - values(source_type o, source_filter_type sf) + values(source_type o, coordination_type sf) : source(std::move(o)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } source_type source; - source_filter_type sourceFilter; + coordination_type coordination; }; values initial; - merge(source_type o, source_filter_type sf) + merge(source_type o, coordination_type sf) : initial(std::move(o), std::move(sf)) { } template - void on_subscribe(Subscriber&& scbr) const { + void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename std::decay::type output_type; + typedef typename coordinator_type::template get::type output_type; struct merge_state_type : public std::enable_shared_from_this , public values { - merge_state_type(values i, output_type oarg) + merge_state_type(values i, coordinator_type coor, output_type oarg) : values(std::move(i)) , pendingCompletions(0) + , coordinator(std::move(coor)) , out(std::move(oarg)) { } // on_completed on the output must wait until all the // subscriptions have received on_completed int pendingCompletions; + coordinator_type coordinator; output_type out; }; + + auto coordinator = initial.coordination.create_coordinator(); + auto selectedDest = on_exception( + [&](){return coordinator(scbr);}, + scbr); + if (selectedDest.empty()) { + return; + } + // take a copy of the values for each subscription - auto state = std::shared_ptr(new merge_state_type(initial, std::forward(scbr))); + auto state = std::shared_ptr(new merge_state_type(initial, std::move(coordinator), std::forward(selectedDest.get()))); composite_subscription outercs; @@ -71,7 +83,7 @@ struct merge : public operator_base::type::value state->out.add(outercs); auto source = on_exception( - [&](){return state->sourceFilter(state->source);}, + [&](){return state->coordinator(state->source);}, state->out); if (source.empty()) { return; @@ -98,7 +110,7 @@ struct merge : public operator_base::type::value })); auto selectedSource = on_exception( - [&](){return state->sourceFilter(st);}, + [&](){return state->coordinator(st);}, state->out); if (selectedSource.empty()) { return; @@ -140,32 +152,32 @@ struct merge : public operator_base::type::value } }; -template +template class merge_factory { - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; - source_filter_type sourceFilter; + coordination_type coordination; public: - merge_factory(source_filter_type sf) - : sourceFilter(std::move(sf)) + merge_factory(coordination_type sf) + : coordination(std::move(sf)) { } template auto operator()(Observable&& source) - -> observable::value_type, merge> { - return observable::value_type, merge>( - merge(std::forward(source), sourceFilter)); + -> observable::value_type, merge> { + return observable::value_type, merge>( + merge(std::forward(source), coordination)); } }; } -template -auto merge(SourceFilter&& sf) - -> detail::merge_factory { - return detail::merge_factory(std::forward(sf)); +template +auto merge(Coordination&& sf) + -> detail::merge_factory { + return detail::merge_factory(std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 963855e..17b2383 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -13,27 +13,28 @@ namespace operators { namespace detail { -template +template struct take_until : public operator_base { typedef typename std::decay::type source_type; typedef typename std::decay::type trigger_source_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; struct values { - values(source_type s, trigger_source_type t, source_filter_type sf) + values(source_type s, trigger_source_type t, coordination_type sf) : source(std::move(s)) , trigger(std::move(t)) - , sourceFilter(std::move(sf)) + , coordination(std::move(sf)) { } source_type source; trigger_source_type trigger; - source_filter_type sourceFilter; + coordination_type coordination; }; values initial; - take_until(source_type s, trigger_source_type t, source_filter_type sf) + take_until(source_type s, trigger_source_type t, coordination_type sf) : initial(std::move(s), std::move(t), std::move(sf)) { } @@ -50,16 +51,17 @@ struct take_until : public operator_base }; template - void on_subscribe(const Subscriber& s) const { + void on_subscribe(Subscriber s) const { typedef Subscriber output_type; struct take_until_state_type : public std::enable_shared_from_this , public values { - take_until_state_type(const values& i, const output_type& oarg) + take_until_state_type(const values& i, coordinator_type coor, const output_type& oarg) : values(i) , mode_value(mode::taking) + , coordinator(std::move(coor)) , out(oarg) { out.add(trigger_lifetime); @@ -68,20 +70,30 @@ struct take_until : public operator_base typename mode::type mode_value; composite_subscription trigger_lifetime; composite_subscription source_lifetime; + coordinator_type coordinator; output_type out; }; + + auto coordinator = initial.coordination.create_coordinator(); + auto selectedDest = on_exception( + [&](){return coordinator(s);}, + s); + if (selectedDest.empty()) { + return; + } + // take a copy of the values for each subscription - auto state = std::shared_ptr(new take_until_state_type(initial, s)); + auto state = std::shared_ptr(new take_until_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); auto trigger = on_exception( - [&](){return state->sourceFilter(state->trigger);}, + [&](){return state->coordinator(state->trigger);}, state->out); if (trigger.empty()) { return; } auto source = on_exception( - [&](){return state->sourceFilter(state->source);}, + [&](){return state->coordinator(state->source);}, state->out); if (source.empty()) { return; @@ -139,34 +151,34 @@ struct take_until : public operator_base } }; -template +template class take_until_factory { typedef typename std::decay::type trigger_source_type; - typedef typename std::decay::type source_filter_type; + typedef typename std::decay::type coordination_type; trigger_source_type trigger_source; - source_filter_type source_filter; + coordination_type coordination; public: - take_until_factory(trigger_source_type t, source_filter_type sf) + take_until_factory(trigger_source_type t, coordination_type sf) : trigger_source(std::move(t)) - , source_filter(std::move(sf)) + , coordination(std::move(sf)) { } template auto operator()(Observable&& source) - -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, SourceFilter>> { - return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, SourceFilter>>( - take_until::type::value_type, Observable, trigger_source_type, SourceFilter>(std::forward(source), trigger_source, source_filter)); + -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, Coordination>> { + return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, Coordination>>( + take_until::type::value_type, Observable, trigger_source_type, Coordination>(std::forward(source), trigger_source, coordination)); } }; } -template -auto take_until(TriggerObservable&& t, SourceFilter&& sf) - -> detail::take_until_factory { - return detail::take_until_factory(std::forward(t), std::forward(sf)); +template +auto take_until(TriggerObservable&& t, Coordination&& sf) + -> detail::take_until_factory { + return detail::take_until_factory(std::forward(t), std::forward(sf)); } } diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp new file mode 100644 index 0000000..ca513a6 --- /dev/null +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -0,0 +1,158 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_COORDINATION_HPP) +#define RXCPP_RX_COORDINATION_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +struct tag_coordinator {}; +struct coordinator_base {typedef tag_coordinator coordinator_tag;}; +template +class is_coordinator +{ + template + static typename C::coordinator_tag* check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_coordinator*>::value; +}; + +struct tag_coordination {}; +struct coordination_base {typedef tag_coordination coordination_tag;}; +template +class is_coordination +{ + template + static typename C::coordination_tag* check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_coordination*>::value; +}; + +template +class coordinator : public coordinator_base +{ + struct not_supported {typedef not_supported type;}; +public: + typedef Input input_type; + typedef Output output_type; + + input_type input; + output_type output; + + template + struct get_observable + { + typedef decltype((*(input_type*)nullptr)((*(Observable*)nullptr))) type; + }; + + template + struct get_subscriber + { + typedef decltype((*(output_type*)nullptr)((*(Subscriber*)nullptr))) type; + }; + + template + struct get + { + typedef typename std::conditional< + is_observable::value, get_observable, typename std::conditional< + is_subscriber::value, get_subscriber, not_supported>::type>::type::type type; + }; + + coordinator(Input i, Output o) : input(i), output(o) {} + + const Input& get_input() const { + return input; + } + + const Output& get_output() const { + return output; + } + + template + auto operator()(Observable o) const + -> typename std::enable_if::value, get_observable>::type::type { + return input(std::move(o)); + static_assert(is_observable::value, "can only synchronize observables"); + } + + template + auto operator()(Subscriber s) const + -> typename std::enable_if::value, get_subscriber>::type::type { + return output(std::move(s)); + static_assert(is_subscriber::value, "can only synchronize subscribers"); + } +}; + +class identity_one_worker : public coordination_base +{ + rxsc::scheduler factory; + + class input_type + { + rxsc::worker controller; + rxsc::scheduler factory; + public: + explicit input_type(rxsc::worker w) + : controller(w) + , factory(rxsc::make_same_worker(w)) + { + } + rxsc::worker get_worker() const { + return controller; + } + rxsc::scheduler get_scheduler() const { + return factory; + } + template + Observable operator()(Observable o) const { + return std::move(o); + static_assert(is_observable::value, "can only synchronize observables"); + } + }; + + class output_type + { + rxsc::worker controller; + rxsc::scheduler factory; + public: + explicit output_type(rxsc::worker w) + : controller(w) + , factory(rxsc::make_same_worker(w)) + { + } + rxsc::worker get_worker() const { + return controller; + } + rxsc::scheduler get_scheduler() const { + return factory; + } + template + Subscriber operator()(Subscriber s) const { + return std::move(s); + static_assert(is_subscriber::value, "can only synchronize subscribers"); + } + }; + +public: + + explicit identity_one_worker(rxsc::scheduler sc) : factory(sc) {} + + typedef coordinator coordinator_type; + + coordinator_type create_coordinator() const { + auto w = factory.create_worker(); + return coordinator_type(input_type(w), output_type(w)); + } +}; + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index e26206a..6f9d903 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -103,9 +103,9 @@ #include "rx-subscription.hpp" #include "rx-observer.hpp" #include "rx-scheduler.hpp" -#include "rx-regulator.hpp" #include "rx-subscriber.hpp" #include "rx-notification.hpp" +#include "rx-coordination.hpp" #include "rx-sources.hpp" #include "rx-subjects.hpp" #include "rx-operators.hpp" diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index f4a211b..17bbdd7 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -325,55 +325,55 @@ public: return lift(rxo::detail::map(std::move(s))); } - template::value> + template::value> struct merge_result; - template - struct merge_result + template + struct merge_result { typedef observable< typename this_type::value_type::value_type, - rxo::detail::merge, SourceFilter>> + rxo::detail::merge, Coordination>> type; - static type make(const this_type* that, SourceFilter sf) { - return type(rxo::detail::merge, SourceFilter>(*that, sf)); + static type make(const this_type* that, Coordination sf) { + return type(rxo::detail::merge, Coordination>(*that, sf)); } }; - template - struct merge_result + template + struct merge_result { typedef this_type type; - static type make(const this_type* that, SourceFilter) { + static type make(const this_type* that, Coordination) { return *that; } }; /// merge -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// auto merge() const - -> typename merge_result::type { - return merge_result::make(this, identity_observable()); + -> typename merge_result::type { + return merge_result::make(this, identity_one_worker(rxsc::make_current_thread())); } /// merge -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coordination is used to synchronize sources from different contexts. /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// - template - auto merge(SourceFilter&& sf) const - -> typename std::enable_if::value && !is_observable::value, - observable::value_type, rxo::detail::merge>>::type { - return observable::value_type, rxo::detail::merge>( - rxo::detail::merge(*this, std::forward(sf))); + template + auto merge(Coordination&& sf) const + -> typename std::enable_if::value && !is_observable::value, + observable::value_type, rxo::detail::merge>>::type { + return observable::value_type, rxo::detail::merge>( + rxo::detail::merge(*this, std::forward(sf))); } /// merge -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// @@ -384,90 +384,90 @@ public: } /// merge -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coordination is used to synchronize sources from different contexts. /// for each item from this observable subscribe. /// for each item from all of the nested observables deliver from the new observable that is returned. /// - template - auto merge(SourceFilter&& sf, Value0 v0, ValueN... vn) const - -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); + template + auto merge(Coordination&& sf, Value0 v0, ValueN... vn) const + -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { + return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); } /// flat_map (AKA SelectMany) -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// template auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::flat_map> { - return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_observable())); + -> observable::value_type, rxo::detail::flat_map> { + return observable::value_type, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_one_worker(rxsc::make_current_thread()))); } /// flat_map (AKA SelectMany) -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coodination is used to synchronize sources from different contexts. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// - template - auto flat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) const - -> observable::value_type, rxo::detail::flat_map> { - return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); + template + auto flat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) const + -> observable::value_type, rxo::detail::flat_map> { + return observable::value_type, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } - template::value> + template::value> struct concat_result; - template - struct concat_result + template + struct concat_result { typedef observable< typename this_type::value_type::value_type, - rxo::detail::concat, SourceFilter>> + rxo::detail::concat, Coordination>> type; - static type make(const this_type* that, SourceFilter sf) { - return type(rxo::detail::concat, SourceFilter>(*that, sf)); + static type make(const this_type* that, Coordination sf) { + return type(rxo::detail::concat, Coordination>(*that, sf)); } }; - template - struct concat_result + template + struct concat_result { typedef this_type type; - static type make(const this_type* that, SourceFilter) { + static type make(const this_type* that, Coordination) { return *that; } }; /// concat -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe to one at a time. in the order received. /// for each item from all of the nested observables deliver from the new observable that is returned. /// auto concat() const - -> typename concat_result::type { - return concat_result::make(this, identity_observable()); + -> typename concat_result::type { + return concat_result::make(this, identity_one_worker(rxsc::make_current_thread())); } /// concat -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coordination is used to synchronize sources from different contexts. /// for each item from this observable subscribe to one at a time. in the order received. /// for each item from all of the nested observables deliver from the new observable that is returned. /// - template - auto concat(SourceFilter&& sf) const - -> typename std::enable_if::value && !is_observable::value, - observable::value_type, rxo::detail::concat>>::type { - return observable::value_type, rxo::detail::concat>( - rxo::detail::concat(*this, std::forward(sf))); + template + auto concat(Coordination&& sf) const + -> typename std::enable_if::value && !is_observable::value, + observable::value_type, rxo::detail::concat>>::type { + return observable::value_type, rxo::detail::concat>( + rxo::detail::concat(*this, std::forward(sf))); } /// concat -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe to one at a time. in the order received. /// for each item from all of the nested observables deliver from the new observable that is returned. /// @@ -478,37 +478,37 @@ public: } /// concat -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coordination is used to synchronize sources from different contexts. /// for each item from this observable subscribe to one at a time. in the order received. /// for each item from all of the nested observables deliver from the new observable that is returned. /// - template - auto concat(SourceFilter&& sf, Value0 v0, ValueN... vn) const - -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); + template + auto concat(Coordination&& sf, Value0 v0, ValueN... vn) const + -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { + return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); } /// concat_map -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// template auto concat_map(CollectionSelector&& s, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::concat_map> { - return observable::value_type, rxo::detail::concat_map>( - rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_observable())); + -> observable::value_type, rxo::detail::concat_map> { + return observable::value_type, rxo::detail::concat_map>( + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_one_worker(rxsc::make_current_thread()))); } /// concat_map -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coordination is used to synchronize sources from different contexts. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. /// for each item from all of the selected observables use the ResultSelector to select a value to emit from the new observable that is returned. /// - template - auto concat_map(CollectionSelector&& s, ResultSelector&& rs, SourceFilter&& sf) const - -> observable::value_type, rxo::detail::concat_map> { - return observable::value_type, rxo::detail::concat_map>( - rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); + template + auto concat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) const + -> observable::value_type, rxo::detail::concat_map> { + return observable::value_type, rxo::detail::concat_map>( + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } /// multicast -> @@ -538,7 +538,7 @@ public: } /// scan -> - /// for each item from this observable use Predicate to combine items into a final value that will be emitted from the new observable that is returned. + /// for each item from this observable use Accumulator to combine items into a value that will be emitted from the new observable that is returned. /// template auto scan(Seed seed, Accumulator&& a) const @@ -548,35 +548,40 @@ public: } /// take -> + /// for the first count items from this observable emit them from the new observable that is returned. /// /// template - auto take(Count&& t) const + auto take(Count t) const -> observable> { return observable>( - rxo::detail::take(*this, std::forward(t))); + rxo::detail::take(*this, t)); } /// take_until -> - /// All sources must be syncronized! This means that calls across all the subscribers must be serial. + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// for each item from this observable until on_next occurs on the TriggerSource, emit them from the new observable that is returned. /// /// template auto take_until(TriggerSource&& t) const - -> observable> { - return observable>( - rxo::detail::take_until(*this, std::forward(t), identity_observable())); + -> typename std::enable_if::value, + observable>>::type { + return observable>( + rxo::detail::take_until(*this, std::forward(t), identity_one_worker(rxsc::make_current_thread()))); } /// take_until -> - /// The source filter can be used to syncronize sources from different contexts. + /// The coordination is used to synchronize sources from different contexts. + /// for each item from this observable until on_next occurs on the TriggerSource, emit them from the new observable that is returned. /// /// - template - auto take_until(TriggerSource&& t, SourceFilter&& sf) const - -> observable> { - return observable>( - rxo::detail::take_until(*this, std::forward(t), std::forward(sf))); + template + auto take_until(TriggerSource&& t, Coordination&& sf) const + -> typename std::enable_if::value && is_coordination::value, + observable>>::type { + return observable>( + rxo::detail::take_until(*this, std::forward(t), std::forward(sf))); } }; diff --git a/Rx/v2/src/rxcpp/rx-regulator.hpp b/Rx/v2/src/rxcpp/rx-regulator.hpp deleted file mode 100644 index 8a7b998..0000000 --- a/Rx/v2/src/rxcpp/rx-regulator.hpp +++ /dev/null @@ -1,101 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once - -#if !defined(RXCPP_RX_REGULATOR_HPP) -#define RXCPP_RX_REGULATOR_HPP - -#include "rx-includes.hpp" - -namespace rxcpp { - -struct tag_resumption {}; -struct resumption_base -{ - typedef tag_resumption resumption_tag; -}; -template -class is_resumption -{ - template - static typename C::resumption_tag* check(int); - template - static void check(...); -public: - static const bool value = std::is_convertible(0)), tag_resumption*>::value; -}; - -namespace detail { - -struct regulator_state_type - : public std::enable_shared_from_this -{ - regulator_state_type() - : isresumed(true) - { - } - rxsc::schedulable resumewith; - bool isresumed; -}; -typedef std::shared_ptr regulator_state; - -} - -// -// passed to subscribe to control the source -// the source must call is_resumed before each onnext -// the source must call resume_with when is_resumed returns false -// the schedulable passed to resume_with must implement a resumption policy; -// forward(undoes drop), unblock(undoes block), subscribe(undoes unsubscribe), -// drain(undoes buffer) -// -class resumption : public resumption_base -{ - detail::regulator_state state; -public: - resumption(){} - explicit resumption(detail::regulator_state st) - : state(st) - { - } - inline bool is_resumed() const { - return state ? state->isresumed : true; - } - inline void resume_with(rxsc::schedulable rw) { - // invalid to call when state is null. - state->resumewith = rw; - } -}; - -// -// owned by observer. the -// observer calls pause to stop the source. The -// observer calls resume when ready for the -// source to send more data. -// -class regulator -{ - detail::regulator_state state; -public: - regulator() - : state(new detail::regulator_state_type()) - { - } - inline void pause() { - state->isresumed = false; - } - inline void resume() { - state->isresumed = true; - auto resumewith = std::move(state->resumewith); - auto local = state->resumewith; - state->resumewith = rxsc::schedulable::empty(local.get_worker()); - local.schedule(); - } - inline resumption get_resumption() { - return resumption(state); - } -}; - -} - -#endif diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 5205907..e0a2a16 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -203,6 +203,11 @@ public: , lifetime(std::move(cs)) { } + worker(composite_subscription cs, worker o) + : inner(o.inner) + , lifetime(std::move(cs)) + { + } inline const composite_subscription& get_subscription() const { return lifetime; @@ -858,5 +863,6 @@ namespace rxsc=schedulers; #include "schedulers/rx-eventloop.hpp" #include "schedulers/rx-immediate.hpp" #include "schedulers/rx-virtualtime.hpp" +#include "schedulers/rx-sameworker.hpp" #endif diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index da432eb..cea6337 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -10,7 +10,7 @@ namespace rxcpp { template -struct subscriber_base : public observer_base, public subscription_base, public resumption_base +struct subscriber_base : public observer_base, public subscription_base { typedef tag_subscriber subscriber_tag; }; @@ -22,7 +22,6 @@ class subscriber : public subscriber_base typedef typename std::decay::type observer_type; composite_subscription lifetime; - resumption controller; observer_type destination; struct detacher @@ -46,28 +45,24 @@ public: subscriber(const this_type& o) : lifetime(o.lifetime) - , controller(o.controller) , destination(o.destination) { } subscriber(this_type&& o) : lifetime(std::move(o.lifetime)) - , controller(std::move(o.controller)) , destination(std::move(o.destination)) { } template - subscriber(composite_subscription cs, resumption r, U&& o) + subscriber(composite_subscription cs, U&& o) : lifetime(std::move(cs)) - , controller(std::move(r)) , destination(std::forward(o)) { } this_type& operator=(this_type o) { lifetime = std::move(o.lifetime); - controller = std::move(o.controller); destination = std::move(o.destination); return *this; } @@ -78,12 +73,6 @@ public: observer_type& get_observer() { return destination; } - const resumption& get_resumption() const { - return controller; - } - resumption& get_resumption() { - return controller; - } const composite_subscription& get_subscription() const { return lifetime; } @@ -91,15 +80,6 @@ public: return lifetime; } - // resumption - // - bool is_resumed() const { - return controller.is_resumed(); - } - void resume_with(rxsc::schedulable rw) { - controller.resume_with(std::move(rw)); - } - // observer // template @@ -165,21 +145,21 @@ template auto make_subscriber( const observer& o) -> subscriber> { - return subscriber>(composite_subscription(), resumption(), o); + return subscriber>(composite_subscription(), o); } template auto make_subscriber(const Observer& o) -> typename std::enable_if< is_observer::value, subscriber>::type { - return subscriber(composite_subscription(), resumption(), o); + return subscriber(composite_subscription(), o); } template auto make_subscriber(const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), resumption(), + return subscriber>>(composite_subscription(), observer>( static_observer(on))); } @@ -189,7 +169,7 @@ auto make_subscriber(const OnNext& on, const OnError& oe) detail::is_on_next_of::value && detail::is_on_error::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), resumption(), + return subscriber>>(composite_subscription(), observer>( static_observer(on, oe))); } @@ -199,7 +179,7 @@ auto make_subscriber(const OnNext& on, const OnCompleted& oc) detail::is_on_next_of::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), resumption(), + return subscriber>>(composite_subscription(), observer>( static_observer(on, detail::OnErrorEmpty(), oc))); } @@ -210,7 +190,7 @@ auto make_subscriber(const OnNext& on, const OnError& oe, const OnCompleted& oc) detail::is_on_error::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), resumption(), + return subscriber>>(composite_subscription(), observer>( static_observer(on, oe, oc))); } @@ -221,21 +201,21 @@ template auto make_subscriber(const composite_subscription& cs, const observer& o) -> subscriber> { - return subscriber>(cs, resumption(), o); + return subscriber>(cs, o); } template auto make_subscriber(const composite_subscription& cs, const Observer& o) -> typename std::enable_if< is_observer::value, subscriber>::type { - return subscriber(cs, resumption(), o); + return subscriber(cs, o); } template auto make_subscriber(const composite_subscription& cs, const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, subscriber>>>::type { - return subscriber>>(cs, resumption(), + return subscriber>>(cs, observer>( static_observer(on))); } @@ -245,7 +225,7 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O detail::is_on_next_of::value && detail::is_on_error::value, subscriber>>>::type { - return subscriber>>(cs, resumption(), + return subscriber>>(cs, observer>( static_observer(on, oe))); } @@ -255,7 +235,7 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O detail::is_on_next_of::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(cs, resumption(), + return subscriber>>(cs, observer>( static_observer(on, detail::OnErrorEmpty(), oc))); } @@ -266,61 +246,7 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O detail::is_on_error::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(cs, resumption(), - observer>( - static_observer(on, oe, oc))); -} - -template -auto make_subscriber(const resumption& r, - const observer& o) - -> subscriber> { - return subscriber>(composite_subscription(), r, o); -} -template -auto make_subscriber(const resumption& r, const Observer& o) - -> typename std::enable_if< - is_observer::value, - subscriber>::type { - return subscriber(composite_subscription(), r, o); -} -template -auto make_subscriber(const resumption& r, const OnNext& on) - -> typename std::enable_if< - detail::is_on_next_of::value, - subscriber>>>::type { - return subscriber>>(composite_subscription(), r, - observer>( - static_observer(on))); -} -template -auto make_subscriber(const resumption& r, const OnNext& on, const OnError& oe) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_error::value, - subscriber>>>::type { - return subscriber>>(composite_subscription(), r, - observer>( - static_observer(on, oe))); -} -template -auto make_subscriber(const resumption& r, const OnNext& on, const OnCompleted& oc) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(composite_subscription(), r, - observer>( - static_observer(on, detail::OnErrorEmpty(), oc))); -} -template -auto make_subscriber(const resumption& r, const OnNext& on, const OnError& oe, const OnCompleted& oc) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_error::value && - detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(composite_subscription(), r, + return subscriber>>(cs, observer>( static_observer(on, oe, oc))); } @@ -331,21 +257,21 @@ template auto make_subscriber(const subscriber& scbr, const observer& o) -> subscriber> { - return subscriber>(scbr.get_subscription(), scbr.get_resumption(), o); + return subscriber>(scbr.get_subscription(), o); } template auto make_subscriber(const subscriber& scbr, const Observer& o) -> typename std::enable_if< is_observer::value, subscriber>::type { - return subscriber(scbr.get_subscription(), scbr.get_resumption(), o); + return subscriber(scbr.get_subscription(), o); } template auto make_subscriber(const subscriber& scbr, const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + return subscriber>>(scbr.get_subscription(), observer>( static_observer(on))); } @@ -355,7 +281,7 @@ auto make_subscriber(const subscriber& scbr, const OnNext detail::is_on_next_of::value && detail::is_on_error::value, subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + return subscriber>>(scbr.get_subscription(), observer>( static_observer(on, oe))); } @@ -365,7 +291,7 @@ auto make_subscriber(const subscriber& scbr, const OnNext detail::is_on_next_of::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + return subscriber>>(scbr.get_subscription(), observer>( static_observer(on, detail::OnErrorEmpty(), oc))); } @@ -376,7 +302,7 @@ auto make_subscriber(const subscriber& scbr, const OnNext detail::is_on_error::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), scbr.get_resumption(), + return subscriber>>(scbr.get_subscription(), observer>( static_observer(on, oe, oc))); } @@ -385,21 +311,21 @@ template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const observer& o) -> subscriber> { - return subscriber>(cs, scbr.get_resumption(), o); + return subscriber>(cs, o); } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const Observer& o) -> typename std::enable_if< is_observer::value, subscriber>::type { - return subscriber(cs, scbr.get_resumption(), o); + return subscriber(cs, o); } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, subscriber>>>::type { - return subscriber>>(cs, scbr.get_resumption(), + return subscriber>>(cs, observer>( static_observer(on))); } @@ -409,7 +335,7 @@ auto make_subscriber(const subscriber& scbr, const compos detail::is_on_next_of::value && detail::is_on_error::value, subscriber>>>::type { - return subscriber>>(cs, scbr.get_resumption(), + return subscriber>>(cs, observer>( static_observer(on, oe))); } @@ -419,7 +345,7 @@ auto make_subscriber(const subscriber& scbr, const compos detail::is_on_next_of::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(cs, scbr.get_resumption(), + return subscriber>>(cs, observer>( static_observer(on, detail::OnErrorEmpty(), oc))); } @@ -430,61 +356,7 @@ auto make_subscriber(const subscriber& scbr, const compos detail::is_on_error::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(cs, scbr.get_resumption(), - observer>( - static_observer(on, oe, oc))); -} - -template -auto make_subscriber(const subscriber& scbr, const resumption& r, - const observer& o) - -> subscriber> { - return subscriber>(scbr.get_subscription(), r, o); -} -template -auto make_subscriber(const subscriber& scbr, const resumption& r, const Observer& o) - -> typename std::enable_if< - is_observer::value, - subscriber>::type { - return subscriber(scbr.get_subscription(), r, o); -} -template -auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on) - -> typename std::enable_if< - detail::is_on_next_of::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), r, - observer>( - static_observer(on))); -} -template -auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on, const OnError& oe) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_error::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), r, - observer>( - static_observer(on, oe))); -} -template -auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on, const OnCompleted& oc) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), r, - observer>( - static_observer(on, detail::OnErrorEmpty(), oc))); -} -template -auto make_subscriber(const subscriber& scbr, const resumption& r, const OnNext& on, const OnError& oe, const OnCompleted& oc) - -> typename std::enable_if< - detail::is_on_next_of::value && - detail::is_on_error::value && - detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), r, + return subscriber>>(cs, observer>( static_observer(on, oe, oc))); } @@ -494,21 +366,7 @@ auto make_subscriber(const subscriber& scbr, const resump template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs) -> subscriber { - return subscriber(cs, scbr.get_resumption(), scbr.get_observer()); -} -// override back-pressure -// -template -auto make_subscriber(const subscriber& scbr, const resumption& r) - -> subscriber { - return subscriber(scbr.get_subscription(), r, scbr.get_observer()); -} -// only keep observer -// -template -auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const resumption& r) - -> subscriber { - return subscriber(cs, r, scbr.get_observer()); + return subscriber(cs, scbr.get_observer()); } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp b/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp new file mode 100644 index 0000000..1059930 --- /dev/null +++ b/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp @@ -0,0 +1,53 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_SCHEDULER_SAME_WORKER_HPP) +#define RXCPP_RX_SCHEDULER_SAME_WORKER_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace schedulers { + +struct same_worker : public scheduler_interface +{ +private: + typedef same_worker this_type; + same_worker(const this_type&); + + rxsc::worker controller; + +public: + explicit same_worker(rxsc::worker w) + : controller(w) + { + } + virtual ~same_worker() + { + } + + virtual clock_type::time_point now() const { + return controller.now(); + } + + virtual worker create_worker(composite_subscription cs) const { + // use different lifetime + auto inner_lifetime = controller.get_subscription(); + auto token = inner_lifetime.add(cs); + cs.add([inner_lifetime, token](){inner_lifetime.remove(token);}); + return worker(cs, controller); + } +}; + +inline scheduler make_same_worker(rxsc::worker w) { + auto i = make_scheduler(w); + return i; +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index f7f9b78..b07d356 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -164,48 +164,71 @@ public: } }; -// -// this type is used by operators that subscribe to -// multiple sources to ensure that the notifications are serialized -// -class synchronize_observable +} + +class syncronize_in_one_worker : public coordination_base { rxsc::scheduler factory; - rxsc::worker controller; -public: - synchronize_observable(rxsc::scheduler sc) - : factory(sc) - , controller(sc.create_worker()) - { - } - synchronize_observable(const synchronize_observable& o) - : factory(o.factory) - // new worker for each copy. this spreads work across threads - // but keeps each use serialized - , controller(factory.create_worker()) - { - } - synchronize_observable(synchronize_observable&& o) - : factory(std::move(o.factory)) - , controller(std::move(o.controller)) + + class input_type { - } - synchronize_observable& operator=(synchronize_observable o) + rxsc::worker controller; + rxsc::scheduler factory; + public: + explicit input_type(rxsc::worker w) + : controller(w) + , factory(rxsc::make_same_worker(w)) + { + } + rxsc::worker get_worker() const { + return controller; + } + rxsc::scheduler get_scheduler() const { + return factory; + } + template + auto operator()(Observable o) const + -> decltype(o.synchronize(controller).ref_count()) { + return o.synchronize(controller).ref_count(); + static_assert(is_observable::value, "can only synchronize observables"); + } + }; + + class output_type { - factory = std::move(o.factory); - controller = std::move(o.controller); - return *this; - } - template - auto operator()(Observable o) - -> decltype(o.synchronize(controller).ref_count()) { - return o.synchronize(controller).ref_count(); - static_assert(is_observable::value, "can only synchronize observables"); + rxsc::worker controller; + rxsc::scheduler factory; + public: + explicit output_type(rxsc::worker w) + : controller(w) + , factory(rxsc::make_same_worker(w)) + { + } + rxsc::worker get_worker() const { + return controller; + } + rxsc::scheduler get_scheduler() const { + return factory; + } + template + Subscriber operator()(Subscriber s) const { + return std::move(s); + static_assert(is_subscriber::value, "can only synchronize subscribers"); + } + }; + +public: + + explicit syncronize_in_one_worker(rxsc::scheduler sc) : factory(sc) {} + + typedef coordinator coordinator_type; + + coordinator_type create_coordinator() const { + auto w = factory.create_worker(); + return coordinator_type(input_type(w), output_type(w)); } }; } -} - #endif diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 864166c..9e2888b 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -27,7 +27,7 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rxsub::synchronize_observable(sc); + auto so = rx::syncronize_in_one_worker(sc); std::atomic c(0); int n = 1; diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 058a645..08cfe71 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 50; +static const int static_tripletCount = 100; SCENARIO("concat_map pythagorian ranges", "[hide][range][concat_map][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -70,7 +70,7 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rxsub::synchronize_observable(sc); + auto so = rx::syncronize_in_one_worker(sc); int c = 0; std::atomic ct(0); diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index cb9b2a0..18ab1b0 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -12,7 +12,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -static const int static_tripletCount = 50; +static const int static_tripletCount = 100; SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; @@ -107,7 +107,7 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rxsub::synchronize_observable(sc); + auto so = rx::syncronize_in_one_worker(sc); int c = 0; std::atomic ct(0); diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 931d26f..50f1cad 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -27,7 +27,7 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rxsub::synchronize_observable(sc); + auto so = rx::syncronize_in_one_worker(sc); std::atomic c(0); int n = 1; diff --git a/Rx/v2/test/sources/defer.cpp b/Rx/v2/test/sources/defer.cpp index 290849b..18d4e42 100644 --- a/Rx/v2/test/sources/defer.cpp +++ b/Rx/v2/test/sources/defer.cpp @@ -31,6 +31,12 @@ SCENARIO("defer stops on completion", "[defer][operators]"){ WHEN("deferred"){ + auto empty = rx::observable<>::empty(); + auto just = rx::observable<>::just(42); + auto one = rx::observable<>::from(42); + auto error = rx::observable<>::error(std::exception_ptr()); + auto runtimeerror = rx::observable<>::error(std::runtime_error("runtime")); + auto res = w.start( [&]() { return rx::observable<>::defer( diff --git a/Rx/v2/test/subscriptions/observer.cpp b/Rx/v2/test/subscriptions/observer.cpp index 83f90e7..259fe0b 100644 --- a/Rx/v2/test/subscriptions/observer.cpp +++ b/Rx/v2/test/subscriptions/observer.cpp @@ -19,14 +19,14 @@ SCENARIO("subscriber traits", "[observer][traits]"){ // static_assert(std::tuple_element<1, decltype(argset)>::type::is_arg, "resumption is a required parameter"); // auto scrbResult = rx::detail::make_subscriber_resolved(rx::rxu::detail::resolve_arg_set(rx::detail::tag_subscriber_set(), rx::resumption(), next, error, completed)); // auto scrbResult = rx::detail::make_subscriber_resolved(argset); - auto scrbResult = rx::make_subscriber(rx::resumption(), next, error, completed); + auto scrbResult = rx::make_subscriber(next, error, completed); auto scrbdup = rx::make_subscriber(scrbResult); auto scrbop = rx::make_subscriber(scrbResult, next, error, completed); - auto scrbsharelifetime = rx::make_subscriber(scrbResult, scrbop.get_resumption(), scrbop.get_observer()); + auto scrbsharelifetime = rx::make_subscriber(scrbResult, scrbop.get_observer()); auto scrbuniquelifetime = rx::make_subscriber(scrbResult, rx::composite_subscription()); auto emptyNext = [](int){}; - auto scrb = rx::make_subscriber(rx::resumption(), emptyNext); + auto scrb = rx::make_subscriber(emptyNext); WHEN("tested"){ THEN("is_observer value is true for subscriber"){ REQUIRE(rx::is_observer::value); -- GitLab From 392fe195291ffd30571c5a31709ff15528703524 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Jun 2014 08:03:20 -0700 Subject: [PATCH 314/782] windows fixes, replace scheduler with coordination --- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 6 +- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 6 +- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 6 +- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 6 +- Rx/v2/src/rxcpp/rx-coordination.hpp | 12 +-- Rx/v2/src/rxcpp/rx-observable.hpp | 109 +++++++++++++++----- Rx/v2/src/rxcpp/sources/rx-error.hpp | 60 +++++++---- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 53 +++++++--- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 83 ++++++++++----- Rx/v2/src/rxcpp/sources/rx-range.hpp | 100 ++++++++++++------ Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 55 ++++++---- Rx/v2/test/operators/concat.cpp | 6 +- Rx/v2/test/operators/concat_map.cpp | 21 ++-- Rx/v2/test/operators/flat_map.cpp | 23 +++-- Rx/v2/test/operators/merge.cpp | 6 +- Rx/v2/test/sources/interval.cpp | 3 +- Rx/v2/test/subscriptions/subscription.cpp | 19 ++-- 18 files changed, 386 insertions(+), 196 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index 9280fb4..57f7143 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -78,7 +78,7 @@ struct concat })); auto selectedSource = on_exception( - [&](){return state->coordinator(std::move(st));}, + [&](){return state->coordinator.in(std::move(st));}, state->out); if (selectedSource.empty()) { return; @@ -117,9 +117,9 @@ struct concat output_type out; }; - auto coordinator = initial.coordination.create_coordinator(); + auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); auto selectedDest = on_exception( - [&](){return coordinator(scbr);}, + [&](){return coordinator.out(scbr);}, scbr); if (selectedDest.empty()) { return; @@ -135,7 +135,7 @@ struct concat state->out.add(state->sourceLifetime); auto source = on_exception( - [&](){return state->coordinator(state->source);}, + [&](){return state->coordinator.in(state->source);}, state->out); if (source.empty()) { return; diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 9f15d80..922d5a2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -128,7 +128,7 @@ struct concat_map })); auto selectedSource = on_exception( - [&](){return state->coordinator(selectedCollection.get());}, + [&](){return state->coordinator.in(selectedCollection.get());}, state->out); if (selectedSource.empty()) { return; @@ -175,7 +175,7 @@ struct concat_map auto coordinator = initial.coordination.create_coordinator(); auto selectedDest = on_exception( - [&](){return coordinator(scbr);}, + [&](){return coordinator.out(scbr);}, scbr); if (selectedDest.empty()) { return; @@ -191,7 +191,7 @@ struct concat_map state->out.add(state->sourceLifetime); auto source = on_exception( - [&](){return state->coordinator(state->source);}, + [&](){return state->coordinator.in(state->source);}, state->out); if (source.empty()) { return; diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index e664399..d09caf9 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -113,7 +113,7 @@ struct flat_map auto coordinator = initial.coordination.create_coordinator(); auto selectedDest = on_exception( - [&](){return coordinator(scbr);}, + [&](){return coordinator.out(scbr);}, scbr); if (selectedDest.empty()) { return; @@ -129,7 +129,7 @@ struct flat_map state->out.add(outercs); auto source = on_exception( - [&](){return state->coordinator(state->source);}, + [&](){return state->coordinator.in(state->source);}, state->out); if (source.empty()) { return; @@ -162,7 +162,7 @@ struct flat_map })); auto selectedSource = on_exception( - [&](){return state->coordinator(selectedCollection.get());}, + [&](){return state->coordinator.in(selectedCollection.get());}, state->out); if (selectedSource.empty()) { return; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index e577777..e2b5d14 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -67,7 +67,7 @@ struct merge : public operator_base::type::value auto coordinator = initial.coordination.create_coordinator(); auto selectedDest = on_exception( - [&](){return coordinator(scbr);}, + [&](){return coordinator.out(scbr);}, scbr); if (selectedDest.empty()) { return; @@ -83,7 +83,7 @@ struct merge : public operator_base::type::value state->out.add(outercs); auto source = on_exception( - [&](){return state->coordinator(state->source);}, + [&](){return state->coordinator.in(state->source);}, state->out); if (source.empty()) { return; @@ -110,7 +110,7 @@ struct merge : public operator_base::type::value })); auto selectedSource = on_exception( - [&](){return state->coordinator(st);}, + [&](){return state->coordinator.in(st);}, state->out); if (selectedSource.empty()) { return; diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 17b2383..c5f2576 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -76,7 +76,7 @@ struct take_until : public operator_base auto coordinator = initial.coordination.create_coordinator(); auto selectedDest = on_exception( - [&](){return coordinator(s);}, + [&](){return coordinator.out(s);}, s); if (selectedDest.empty()) { return; @@ -86,14 +86,14 @@ struct take_until : public operator_base auto state = std::shared_ptr(new take_until_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); auto trigger = on_exception( - [&](){return state->coordinator(state->trigger);}, + [&](){return state->coordinator.in(state->trigger);}, state->out); if (trigger.empty()) { return; } auto source = on_exception( - [&](){return state->coordinator(state->source);}, + [&](){return state->coordinator.in(state->source);}, state->out); if (source.empty()) { return; diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index ca513a6..880fc5c 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -77,15 +77,15 @@ public: } template - auto operator()(Observable o) const - -> typename std::enable_if::value, get_observable>::type::type { + auto in(Observable o) const + -> typename get_observable::type { return input(std::move(o)); static_assert(is_observable::value, "can only synchronize observables"); } template - auto operator()(Subscriber s) const - -> typename std::enable_if::value, get_subscriber>::type::type { + auto out(Subscriber s) const + -> typename get_subscriber::type { return output(std::move(s)); static_assert(is_subscriber::value, "can only synchronize subscribers"); } @@ -147,8 +147,8 @@ public: typedef coordinator coordinator_type; - coordinator_type create_coordinator() const { - auto w = factory.create_worker(); + coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + auto w = factory.create_worker(std::move(cs)); return coordinator_type(input_type(w), output_type(w)); } }; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 17bbdd7..a2adb21 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -524,9 +524,10 @@ public: /// synchronize -> /// turns a cold observable hot and allows connections to the source to be independent of subscriptions /// - auto synchronize(rxsc::worker w, composite_subscription cs = composite_subscription()) const - -> decltype(multicast(rxsub::synchronize(w, cs))) { - return multicast(rxsub::synchronize(w, cs)); + template + auto synchronize(Coordination cn, composite_subscription cs = composite_subscription()) const + -> decltype(multicast(rxsub::synchronize(std::move(cn), cs))) { + return multicast(rxsub::synchronize(std::move(cn), cs)); } /// publish -> @@ -602,9 +603,24 @@ class observable ~observable(); public: template - static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) - -> decltype(rxs::range(first, last, step, sc)) { - return rxs::range(first, last, step, sc); + static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1) + -> decltype(rxs::range(first, last, step, identity_one_worker(rxsc::make_current_thread()))) { + return rxs::range(first, last, step, identity_one_worker(rxsc::make_current_thread())); + } + template + static auto range(T first, T last, ptrdiff_t step, Coordination cn) + -> decltype(rxs::range(first, last, step, std::move(cn))) { + return rxs::range(first, last, step, std::move(cn)); + } + template + static auto range(T first, T last, Coordination cn) + -> decltype(rxs::range(first, last, std::move(cn))) { + return rxs::range(first, last, std::move(cn)); + } + template + static auto range(T first, Coordination cn) + -> decltype(rxs::range(first, std::move(cn))) { + return rxs::range(first, std::move(cn)); } template static auto never() @@ -616,40 +632,77 @@ public: -> decltype(rxs::defer(std::move(of))) { return rxs::defer(std::move(of)); } - static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable { - return observable(rxs::detail::interval(initial, period, sc)); + static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period) + -> decltype(rxs::interval(initial, period)) { + return rxs::interval(initial, period); + } + template + static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, Coordination cn) + -> decltype(rxs::interval(initial, period, std::move(cn))) { + return rxs::interval(initial, period, std::move(cn)); } template - static auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) - -> decltype(rxs::iterate(std::move(c), sc)) { - return rxs::iterate(std::move(c), sc); + static auto iterate(Collection c) + -> decltype(rxs::iterate(std::move(c), identity_one_worker(rxsc::make_current_thread()))) { + return rxs::iterate(std::move(c), identity_one_worker(rxsc::make_current_thread())); + } + template + static auto iterate(Collection c, Coordination cn) + -> decltype(rxs::iterate(std::move(c), std::move(cn))) { + return rxs::iterate(std::move(c), std::move(cn)); + } + template + static auto from() + -> decltype( rxs::from()) { + return rxs::from(); + } + template + static auto from(Coordination cn) + -> typename std::enable_if::value, + decltype( rxs::from(std::move(cn)))>::type { + return rxs::from(std::move(cn)); } template static auto from(Value0 v0, ValueN... vn) - -> decltype(rxs::from(v0, vn...)) { - return rxs::from(v0, vn...); + -> typename std::enable_if::value, + decltype( rxs::from(v0, vn...))>::type { + return rxs::from(v0, vn...); } - template - static auto from(Value0 v0, ValueN... vn, rxsc::scheduler sc) - -> decltype(rxs::from(v0, vn..., sc)) { - return rxs::from(v0, vn..., sc); + template + static auto from(Coordination cn, Value0 v0, ValueN... vn) + -> typename std::enable_if::value, + decltype( rxs::from(std::move(cn), v0, vn...))>::type { + return rxs::from(std::move(cn), v0, vn...); } template - static auto empty(rxsc::scheduler sc = rxsc::make_immediate()) - -> observable>> { - std::array c; - return observable>>(rxs::detail::iterate>(std::move(c), sc)); + static auto empty() + -> decltype(from()) { + return from(); + } + template + static auto empty(Coordination cn) + -> decltype(from(std::move(cn), std::array())) { + return from(std::move(cn), std::array()); } template - static auto just(T v, rxsc::scheduler sc = rxsc::make_immediate()) - -> decltype(rxs::from(v, sc)) { - return rxs::from(v, sc); + static auto just(T v) + -> decltype(from(std::move(v))) { + return from(std::move(v)); + } + template + static auto just(T v, Coordination cn) + -> decltype(from(std::move(cn), std::move(v))) { + return from(std::move(cn), std::move(v)); } template - static auto error(Exception&& e, rxsc::scheduler sc = rxsc::make_immediate()) - -> observable> { - return rxs::error(std::forward(e), sc); + static auto error(Exception&& e) + -> decltype(rxs::error(std::forward(e))) { + return rxs::error(std::forward(e)); + } + template + static auto error(Exception&& e, Coordination cn) + -> decltype(rxs::error(std::forward(e), std::move(cn))) { + return rxs::error(std::forward(e), std::move(cn)); } }; diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index aa8d89c..f8352c9 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -13,25 +13,29 @@ namespace sources { namespace detail { -template +template struct error : public source_base { - typedef error this_type; + typedef error this_type; + + typedef typename std::decay::type coordination_type; + + typedef typename coordination_type::coordinator_type coordinator_type; struct error_initial_type { - error_initial_type(std::exception_ptr e, rxsc::scheduler sc) + error_initial_type(std::exception_ptr e, coordination_type cn) : exception(e) - , factory(sc) + , coordination(std::move(cn)) { } std::exception_ptr exception; - rxsc::scheduler factory; + coordination_type coordination; }; error_initial_type initial; - error(std::exception_ptr e, rxsc::scheduler sc) - : initial(e, sc) + error(std::exception_ptr e, coordination_type cn) + : initial(e, std::move(cn)) { } @@ -39,17 +43,26 @@ struct error : public source_base void on_subscribe(Subscriber o) const { // creates a worker whose lifetime is the same as this subscription - auto controller = initial.factory.create_worker(o.get_subscription()); + auto coordinator = initial.coordination.create_coordinator(o.get_subscription()) + auto controller = coordinator.get_output().get_worker(); auto exception = initial.exception; + auto selectedDest = on_exception( + [&](){return coordinator.out(o);}, + o); + if (selectedDest.empty()) { + return; + } + controller.schedule( [=](const rxsc::schedulable&){ - if (!o.is_subscribed()) { + auto& dest = selectedDest.get(); + if (!dest.is_subscribed()) { // terminate loop return; } - o.on_error(exception); + dest.on_error(exception); // o is unsubscribed }); } @@ -58,26 +71,31 @@ struct error : public source_base struct throw_ptr_tag{}; struct throw_instance_tag{}; -template -auto make_error(throw_ptr_tag&&, std::exception_ptr exception, rxsc::scheduler scheduler) - -> observable> { - return observable>(error(std::move(exception), std::move(scheduler))); +template +auto make_error(throw_ptr_tag&&, std::exception_ptr exception, Coordination cn) + -> observable> { + return observable>(error(std::move(exception), std::move(cn))); } -template -auto make_error(throw_instance_tag&&, E e, rxsc::scheduler scheduler) - -> observable> { +template +auto make_error(throw_instance_tag&&, E e, Coordination cn) + -> observable> { std::exception_ptr exception; try {throw e;} catch(...) {exception = std::current_exception();} - return observable>(error(std::move(exception), std::move(scheduler))); + return observable>(error(std::move(exception), std::move(cn))); } } template -auto error(E e, rxsc::scheduler sc = rxsc::make_current_thread()) - -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(sc))) { - return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(sc)); +auto error(E e) + -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_one_worker(rxsc::make_immediate()))) { + return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_one_worker(rxsc::make_immediate())); +} +template +auto error(E e, Coordination cn) + -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(cn))) { + return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(cn)); } } diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 5b77e90..d0b2558 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -13,52 +13,75 @@ namespace sources { namespace detail { +template struct interval : public source_base { - typedef interval this_type; + typedef interval this_type; + + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; struct interval_initial_type { - interval_initial_type(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, rxsc::scheduler sc) + interval_initial_type(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, coordination_type cn) : initial(i) , period(p) - , factory(sc) + , coordination(std::move(cn)) { } rxsc::scheduler::clock_type::time_point initial; rxsc::scheduler::clock_type::duration period; - rxsc::scheduler factory; + coordination_type coordination; }; interval_initial_type initial; - interval(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, rxsc::scheduler sc) - : initial(i, p, sc) + interval(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, coordination_type cn) + : initial(i, p, std::move(cn)) { } template void on_subscribe(Subscriber o) const { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename coordinator_type::template get::type output_type; // creates a worker whose lifetime is the same as this subscription - auto controller = initial.factory.create_worker(o.get_subscription()); + auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); + + auto selectedDest = on_exception( + [&](){return coordinator.out(o);}, + o); + if (selectedDest.empty()) { + return; + } + auto counter = std::make_shared(0); - controller.schedule_periodically( + coordinator.get_output().get_worker().schedule_periodically( initial.initial, initial.period, - [o, counter](const rxsc::schedulable&) { + [selectedDest, counter](const rxsc::schedulable&) { // send next value - o.on_next(++(*counter)); + selectedDest.get().on_next(++(*counter)); }); } }; } -/* -auto interval(rxsc::scheduler::clock_type::time_point i, rxsc::scheduler::clock_type::duration p, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable { - return observable(detail::interval(i, p, sc)); +template +static auto interval(rxsc::scheduler::clock_type::time_point initial, Duration period) + -> observable> { + return observable>( + rxs::detail::interval(initial, period, identity_one_worker(rxsc::make_current_thread()))); + static_assert(std::is_same::value, "duration must be rxsc::scheduler::clock_type::duration"); +} +template +static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, Coordination cn) + -> observable> { + return observable>( + rxs::detail::interval(initial, period, std::move(cn))); } -*/ + } } diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index dc5be36..0b04c44 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -35,37 +35,44 @@ struct iterate_traits typedef typename std::iterator_traits::value_type value_type; }; -template +template struct iterate : public source_base::value_type> { - typedef iterate this_type; + typedef iterate this_type; typedef iterate_traits traits; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + typedef typename traits::collection_type collection_type; typedef typename traits::iterator_type iterator_type; struct iterate_initial_type { - iterate_initial_type(collection_type c, rxsc::scheduler sc) + iterate_initial_type(collection_type c, coordination_type cn) : collection(std::move(c)) - , factory(sc) + , coordination(std::move(cn)) { } collection_type collection; - rxsc::scheduler factory; + coordination_type coordination; }; iterate_initial_type initial; - iterate(collection_type c, rxsc::scheduler sc) - : initial(std::move(c), std::move(sc)) + iterate(collection_type c, coordination_type cn) + : initial(std::move(c), std::move(cn)) { } template void on_subscribe(Subscriber o) const { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename coordinator_type::template get::type output_type; + struct iterate_state_type : public iterate_initial_type { - iterate_state_type(const iterate_initial_type& i, Subscriber o) + iterate_state_type(const iterate_initial_type& i, output_type o) : iterate_initial_type(i) , cursor(std::begin(iterate_initial_type::collection)) , end(std::end(iterate_initial_type::collection)) @@ -81,12 +88,21 @@ struct iterate : public source_base::value_t } mutable iterator_type cursor; iterator_type end; - mutable Subscriber out; + mutable output_type out; }; - iterate_state_type state(initial, std::move(o)); // creates a worker whose lifetime is the same as this subscription - auto controller = state.factory.create_worker(state.out.get_subscription()); + auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); + auto selectedDest = on_exception( + [&](){return coordinator.out(o);}, + o); + if (selectedDest.empty()) { + return; + } + + iterate_state_type state(initial, std::move(selectedDest.get())); + + auto controller = coordinator.get_output().get_worker(); controller.schedule( [state](const rxsc::schedulable& self){ @@ -116,25 +132,42 @@ struct iterate : public source_base::value_t } template -auto iterate(Collection c, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable::value_type, detail::iterate> { - return observable::value_type, detail::iterate>( - detail::iterate(std::move(c), sc)); +auto iterate(Collection c) + -> observable::value_type, detail::iterate> { + return observable::value_type, detail::iterate>( + detail::iterate(std::move(c), identity_one_worker(rxsc::make_current_thread()))); +} +template +auto iterate(Collection c, Coordination cn) + -> observable::value_type, detail::iterate> { + return observable::value_type, detail::iterate>( + detail::iterate(std::move(c), std::move(cn))); } +template +auto from() + -> decltype(iterate(std::array(), identity_one_worker(rxsc::make_immediate()))) { + return iterate(std::array(), identity_one_worker(rxsc::make_immediate())); +} +template +auto from(Coordination cn) + -> typename std::enable_if::value, + decltype( iterate(std::array(), std::move(cn)))>::type { + return iterate(std::array(), std::move(cn)); +} template auto from(Value0 v0, ValueN... vn) - -> observable>> { - std::array c = {v0, vn...}; - return observable>>( - rxs::detail::iterate>(std::move(c), rxsc::make_current_thread())); + -> typename std::enable_if::value, + decltype(iterate(std::array(), identity_one_worker()))>::type { + std::array c = {v0, vn...}; + return iterate(std::move(c), identity_one_worker(rxsc::make_immediate())); } -template -auto from(Value0 v0, ValueN... vn, rxsc::scheduler sc) - -> observable>> { - std::array c = {v0, vn...}; - return observable>>( - rxs::detail::iterate>(std::move(c), sc)); +template +auto from(Coordination cn, Value0 v0, ValueN... vn) + -> typename std::enable_if::value, + decltype(iterate(std::array(), std::move(cn)))>::type { + std::array c = {v0, vn...}; + return iterate(std::move(c), std::move(cn)); } } diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index c8c4ae0..cf82950 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -13,48 +13,74 @@ namespace sources { namespace detail { -template +template struct range : public source_base { - struct state_type + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + + struct range_state_type { - T next; + range_state_type(T f, T l, ptrdiff_t s, coordination_type cn) + : next(f) + , last(l) + , step(s) + , coordination(std::move(cn)) + { + } + mutable T next; T last; ptrdiff_t step; - rxsc::scheduler sc; - rxsc::worker w; + coordination_type coordination; }; - state_type init; - range(T f, T l, ptrdiff_t s, rxsc::scheduler sc) + range_state_type initial; + range(T f, T l, ptrdiff_t s, coordination_type cn) + : initial(f, l, s, std::move(cn)) { - init.next = f; - init.last = l; - init.step = s; - init.sc = sc; } template void on_subscribe(Subscriber o) const { - auto state = std::make_shared(init); + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename coordinator_type::template get::type output_type; + // creates a worker whose lifetime is the same as this subscription - state->w = state->sc.create_worker(o.get_subscription()); - state->w.schedule( + auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); + auto selectedDest = on_exception( + [&](){return coordinator.out(o);}, + o); + if (selectedDest.empty()) { + return; + } + + auto controller = coordinator.get_output().get_worker(); + + auto state = initial; + + controller.schedule( [=](const rxsc::schedulable& self){ - if (!o.is_subscribed()) { + auto& dest = selectedDest.get(); + if (!dest.is_subscribed()) { // terminate loop return; } // send next value - o.on_next(state->next); - if (std::abs(state->last - state->next) < std::abs(state->step)) { - if (state->last != state->next) { - o.on_next(state->last); + dest.on_next(state.next); + if (!dest.is_subscribed()) { + // terminate loop + return; + } + + if (std::abs(state.last - state.next) < std::abs(state.step)) { + if (state.last != state.next) { + dest.on_next(state.last); } - o.on_completed(); + dest.on_completed(); // o is unsubscribed return; } - state->next = static_cast(state->step + state->next); + state.next = static_cast(state.step + state.next); // tail recurse this same action to continue loop self(); @@ -65,16 +91,30 @@ struct range : public source_base } template -auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable> { - return observable>( - detail::range(first, last, step, sc)); +auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1) + -> observable> { + return observable>( + detail::range(first, last, step, identity_one_worker(rxsc::make_current_thread()))); } -template -auto range(T first = 0, rxsc::scheduler sc = rxsc::make_current_thread()) - -> observable> { - return observable>( - detail::range(first, std::numeric_limits::max(), 1, sc)); +template +auto range(T first, T last, ptrdiff_t step, Coordination cn) + -> observable> { + return observable>( + detail::range(first, last, step, std::move(cn))); +} +template +auto range(T first, T last, Coordination cn) + -> typename std::enable_if::value, + observable>>::type { + return observable>( + detail::range(first, last, 1, std::move(cn))); +} +template +auto range(T first, Coordination cn) + -> typename std::enable_if::value, + observable>>::type { + return observable>( + detail::range(first, std::numeric_limits::max(), 1, std::move(cn))); } } diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index b07d356..7b72cf7 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -13,12 +13,16 @@ namespace subjects { namespace detail { -template +template class synchronize_observer : public detail::multicast_observer { - typedef synchronize_observer this_type; + typedef synchronize_observer this_type; typedef detail::multicast_observer base_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + typedef typename coordinator_type::template get>::type output_type; + struct synchronize_observer_state : public std::enable_shared_from_this { typedef rxn::notification notification_type; @@ -41,7 +45,8 @@ class synchronize_observer : public detail::multicast_observer composite_subscription lifetime; rxsc::worker processor; mutable typename mode::type current; - subscriber destination; + coordinator_type coordinator; + output_type destination; void ensure_processing(std::unique_lock& guard) const { if (!guard.owns_lock()) { @@ -50,6 +55,7 @@ class synchronize_observer : public detail::multicast_observer if (current == mode::Empty) { current = mode::Processing; auto keepAlive = this->shared_from_this(); + auto processor = coordinator.get_output().get_worker(); processor.schedule(lifetime, [keepAlive, this](const rxsc::schedulable& self){ try { std::unique_lock guard(lock); @@ -78,9 +84,9 @@ class synchronize_observer : public detail::multicast_observer } } - synchronize_observer_state(rxsc::worker w, composite_subscription cs, subscriber scbr) + synchronize_observer_state(coordinator_type coor, composite_subscription cs, output_type scbr) : lifetime(std::move(cs)) - , processor(std::move(w)) + , coordinator(std::move(coor)) , current(mode::Empty) , destination(std::move(scbr)) { @@ -116,11 +122,22 @@ class synchronize_observer : public detail::multicast_observer std::shared_ptr state; public: - synchronize_observer(rxsc::worker w, composite_subscription dl, composite_subscription il) + synchronize_observer(coordination_type cn, composite_subscription dl, composite_subscription il) : base_type(dl) - , state(std::make_shared( - std::move(w), std::move(il), make_subscriber(dl, make_observer_dynamic( *static_cast(this) )))) - {} + { + auto o = make_subscriber(dl, make_observer_dynamic( *static_cast(this) )); + + // creates a worker whose lifetime is the same as the destination subscription + auto coordinator = cn.create_coordinator(dl); + auto selectedDest = on_exception( + [&](){return coordinator.out(o);}, + o); + if (selectedDest.empty()) { + return; + } + + state = std::make_shared(std::move(coordinator), std::move(il), std::move(selectedDest.get())); + } template void on_next(V v) const { @@ -136,16 +153,16 @@ public: } -template +template class synchronize { composite_subscription lifetime; - detail::synchronize_observer s; + detail::synchronize_observer s; public: - explicit synchronize(rxsc::worker w, composite_subscription cs = composite_subscription()) + explicit synchronize(Coordination cn, composite_subscription cs = composite_subscription()) : lifetime(composite_subscription()) - , s(std::move(w), std::move(cs), lifetime) + , s(std::move(cn), std::move(cs), lifetime) { } @@ -154,7 +171,7 @@ public: } subscriber get_subscriber() const { - return make_subscriber(lifetime, make_observer_dynamic(observer>(s))); + return make_subscriber(lifetime, make_observer_dynamic(observer>(s))); } observable get_observable() const { @@ -174,10 +191,12 @@ class syncronize_in_one_worker : public coordination_base { rxsc::worker controller; rxsc::scheduler factory; + identity_one_worker coordination; public: explicit input_type(rxsc::worker w) : controller(w) , factory(rxsc::make_same_worker(w)) + , coordination(factory) { } rxsc::worker get_worker() const { @@ -188,8 +207,8 @@ class syncronize_in_one_worker : public coordination_base } template auto operator()(Observable o) const - -> decltype(o.synchronize(controller).ref_count()) { - return o.synchronize(controller).ref_count(); + -> decltype(o.synchronize(coordination).ref_count()) { + return o.synchronize(coordination).ref_count(); static_assert(is_observable::value, "can only synchronize observables"); } }; @@ -223,8 +242,8 @@ public: typedef coordinator coordinator_type; - coordinator_type create_coordinator() const { - auto w = factory.create_worker(); + coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + auto w = factory.create_worker(std::move(cs)); return coordinator_type(input_type(w), output_type(w)); } }; diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 9e2888b..aadc1fb 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -33,11 +33,11 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, sc) + rxs::range(0, sectionCount - 1, 1, so) .concat( so, - rxs::range(sectionCount, sectionCount * 2 - 1, 1, sc), - rxs::range(sectionCount * 2, onnextcalls - 1, 1, sc)) + rxs::range(sectionCount, sectionCount * 2 - 1, 1, so), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) .subscribe( [&c](int x){ ++c;}, diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 08cfe71..ffe8e85 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -23,19 +23,20 @@ SCENARIO("concat_map pythagorian ranges", "[hide][range][concat_map][pythagorian auto sc = rxsc::make_immediate(); //auto sc = rxsc::make_current_thread(); + auto so = rx::identity_one_worker(sc); int c = 0; int ct = 0; int n = 1; auto start = clock::now(); auto triples = - rxs::range(1, sc) + rxs::range(1, so) .concat_map( - [&c, sc](int z){ - return rxs::range(1, z, 1, sc) + [&c, so](int z){ + return rxs::range(1, z, 1, so) .concat_map( - [&c, sc, z](int x){ - return rxs::range(x, z, 1, sc) + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 @@ -77,13 +78,13 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] int n = 1; auto start = clock::now(); auto triples = - rxs::range(1, sc) + rxs::range(1, so) .concat_map( - [&c, sc, so](int z){ - return rxs::range(1, z, 1, sc) + [&c, so](int z){ + return rxs::range(1, z, 1, so) .concat_map( - [&c, sc, z](int x){ - return rxs::range(x, z, 1, sc) + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) .filter([&c, z, x](int y){ ++c; if (x*x + y*y == z*z) { diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 18ab1b0..f3ada84 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -60,19 +60,20 @@ SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][pe auto sc = rxsc::make_immediate(); //auto sc = rxsc::make_current_thread(); + auto so = rx::syncronize_in_one_worker(sc); int c = 0; int ct = 0; int n = 1; auto start = clock::now(); auto triples = - rxs::range(1, sc) + rxs::range(1, so) .flat_map( - [&c, sc](int z){ - return rxs::range(1, z, 1, sc) + [&c, so](int z){ + return rxs::range(1, z, 1, so) .flat_map( - [&c, sc, z](int x){ - return rxs::range(x, z, 1, sc) + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) .filter([&c, z, x](int y){++c; return x*x + y*y == z*z;}) .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 @@ -107,20 +108,20 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rx::syncronize_in_one_worker(sc); + auto so = rx::identity_one_worker(sc); int c = 0; std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = - rxs::range(1, sc) + rxs::range(1, so) .flat_map( - [&c, sc, so](int z){ - return rxs::range(1, z, 1, sc) + [&c, so](int z){ + return rxs::range(1, z, 1, so) .flat_map( - [&c, sc, z](int x){ - return rxs::range(x, z, 1, sc) + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) .filter([&c, z, x](int y){ ++c; if (x*x + y*y == z*z) { diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 50f1cad..21f722e 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -33,11 +33,11 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, sc) + rxs::range(0, sectionCount - 1, 1, so) .merge( so, - rxs::range(sectionCount, (sectionCount * 2) - 1, 1, sc), - rxs::range(sectionCount * 2, onnextcalls - 1, 1, sc)) + rxs::range(sectionCount, (sectionCount * 2) - 1, 1, so), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) .subscribe( [&c](int x){ ++c;}, diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp index 73ce4c8..7aa621f 100644 --- a/Rx/v2/test/sources/interval.cpp +++ b/Rx/v2/test/sources/interval.cpp @@ -87,10 +87,11 @@ SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf]"){ int c = 0; auto sc = rxsc::make_current_thread(); + auto so = rx::syncronize_in_one_worker(sc); auto start = sc.now() + seconds(2); auto period = seconds(1); rx::composite_subscription cs; - rx::observable<>::interval(start, period, sc) + rx::observable<>::interval(start, period, so) .subscribe( cs, [=, &c](long counter){ diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 1c040ba..29761ce 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -25,14 +25,14 @@ SCENARIO("for loop subscribes", "[hide][for][just][subscribe][long][perf]"){ for (int i = 0; i < subscriptions; i++) { rx::observable<>::just(1) .map([](int i) { - return (std::stringstream() << i).str(); - //return std::string("1"); + std::stringstream serializer; + serializer << i; + return serializer.str(); }) .map([](const std::string& s) { int i; std::stringstream(s) >> i; return i; - //return 1; }) .subscribe([&](int i){ ++c; @@ -62,6 +62,7 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto w = sc.create_worker(); auto el = rxsc::make_event_loop(); + auto es = rx::syncronize_in_one_worker(el); int runs = 10; @@ -97,10 +98,10 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto start = clock::now(); auto ew = el.create_worker(); std::atomic v(0); - auto s0 = rxs::range(0, 499, 1, el) + auto s0 = rxs::range(0, 499, 1, es) .lift(liftrequirecompletion) .as_dynamic() - .synchronize(ew) + .synchronize(es) .ref_count() .lift(liftrequirecompletion) .subscribe( @@ -111,10 +112,10 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf [&](){ ++c; })); - auto s1 = rxs::range(500, 999, 1, el) + auto s1 = rxs::range(500, 999, 1, es) .lift(liftrequirecompletion) .as_dynamic() - .synchronize(ew) + .synchronize(es) .ref_count() .lift(liftrequirecompletion) .subscribe( @@ -125,10 +126,10 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf [&](){ ++c; })); - auto s2 = rxs::range(1000, 1499, 1, el) + auto s2 = rxs::range(1000, 1499, 1, es) .lift(liftrequirecompletion) .as_dynamic() - .synchronize(ew) + .synchronize(es) .ref_count() .lift(liftrequirecompletion) .subscribe( -- GitLab From a88a47bb3237d2095af9be17ffc412c0a44bd427 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Jun 2014 08:24:53 -0700 Subject: [PATCH 315/782] osx fixes, abort on unhandled error --- Rx/v2/src/rxcpp/rx-observer.hpp | 5 ++++- Rx/v2/src/rxcpp/sources/rx-error.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 8 +++++++- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 12 ++++++------ 4 files changed, 18 insertions(+), 9 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index b6bad50..d9f20a0 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -25,7 +25,10 @@ struct OnNextEmpty }; struct OnErrorEmpty { - void operator()(std::exception_ptr) const {} + void operator()(std::exception_ptr) const { + // error implicitly ignored, abort + abort(); + } }; struct OnCompletedEmpty { diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index f8352c9..0c2f67c 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -43,7 +43,7 @@ struct error : public source_base void on_subscribe(Subscriber o) const { // creates a worker whose lifetime is the same as this subscription - auto coordinator = initial.coordination.create_coordinator(o.get_subscription()) + auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); auto controller = coordinator.get_output().get_worker(); auto exception = initial.exception; diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index d0b2558..35b8ed6 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -67,10 +67,16 @@ struct interval : public source_base } }; +template +struct delay_resolution +{ + typedef observable> type; +}; + } template static auto interval(rxsc::scheduler::clock_type::time_point initial, Duration period) - -> observable> { + -> typename detail::delay_resolution::type { return observable>( rxs::detail::interval(initial, period, identity_one_worker(rxsc::make_current_thread()))); static_assert(std::is_same::value, "duration must be rxsc::scheduler::clock_type::duration"); diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index 0b04c44..d3c97b5 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -151,22 +151,22 @@ auto from() } template auto from(Coordination cn) - -> typename std::enable_if::value, + -> typename std::enable_if::value, decltype( iterate(std::array(), std::move(cn)))>::type { return iterate(std::array(), std::move(cn)); } template auto from(Value0 v0, ValueN... vn) - -> typename std::enable_if::value, - decltype(iterate(std::array(), identity_one_worker()))>::type { - std::array c = {v0, vn...}; + -> typename std::enable_if::value, + decltype(iterate(std::array(), identity_one_worker(rxsc::make_immediate())))>::type { + std::array c = {v0, vn...}; return iterate(std::move(c), identity_one_worker(rxsc::make_immediate())); } template auto from(Coordination cn, Value0 v0, ValueN... vn) - -> typename std::enable_if::value, + -> typename std::enable_if::value, decltype(iterate(std::array(), std::move(cn)))>::type { - std::array c = {v0, vn...}; + std::array c = {v0, vn...}; return iterate(std::move(c), std::move(cn)); } -- GitLab From aad3c9f8ba35dd90af0252083a1b3cf749083835 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Jun 2014 22:15:45 -0700 Subject: [PATCH 316/782] add combine_latest --- .../src/rxcpp/operators/rx-combine_latest.hpp | 225 ++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 60 ++++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/src/rxcpp/rx-util.hpp | 23 ++ Rx/v2/test/operators/combine_latest.cpp | 88 +++++++ projects/CMake/CMakeLists.txt | 1 + 6 files changed, 395 insertions(+), 3 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp create mode 100644 Rx/v2/test/operators/combine_latest.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp new file mode 100644 index 0000000..1c9281a --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -0,0 +1,225 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_COMBINE_LATEST_HPP) +#define RXCPP_OPERATORS_RX_COMBINE_LATEST_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct combine_latest_traits { + static_assert(rxu::all_true::value...>::value, "combine_latest requires observables"); + + typedef std::tuple tuple_source_type; + typedef std::tuple...> tuple_source_value_type; + + typedef typename std::decay::type selector_type; + typedef typename std::decay::type coordination_type; + + struct tag_not_valid {}; + template + static auto check(int) -> decltype((*(CS*)nullptr)((*(CVN*)nullptr)...)); + template + static tag_not_valid check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "combine_latest Selector must be a function with the signature value_type(Observable::value_type...)"); + + typedef decltype(check(0)) value_type; +}; + +template +struct combine_latest : public operator_base::value_type> +{ + typedef combine_latest this_type; + + typedef combine_latest_traits traits; + + typedef typename traits::tuple_source_type tuple_source_type; + typedef typename traits::tuple_source_value_type tuple_source_value_type; + + typedef typename traits::selector_type selector_type; + + typedef typename traits::coordination_type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + + struct values + { + values(tuple_source_type o, selector_type s, coordination_type sf) + : source(std::move(o)) + , selector(std::move(s)) + , coordination(std::move(sf)) + { + } + tuple_source_type source; + selector_type selector; + coordination_type coordination; + }; + values initial; + + combine_latest(coordination_type sf, selector_type s, tuple_source_type ts) + : initial(std::move(ts), std::move(s), std::move(sf)) + { + } + + template + void subscribe(std::shared_ptr state, rxu::values) const { + bool subscribed[] = {(subscribe(state), true)...}; + } + template + void subscribe(std::shared_ptr state) const { + + typedef typename std::tuple_element::type::value_type source_value_type; + + composite_subscription innercs; + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.add(innercs); + + auto source = on_exception( + [&](){return state->coordinator.in(std::get(state->source));}, + state->out); + if (source.empty()) { + return; + } + + ++state->pendingCompletions; + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + source->subscribe( + state->out, + innercs, + // on_next + [state](source_value_type st) { + + auto& value = std::get(state->latest); + + if (value.empty()) { + ++state->valuesSet; + } + + value.reset(st); + + if (state->valuesSet == sizeof... (ObservableN)) { + auto selectedResult = on_exception( + [&](){ + return rxu::apply(state->latest, [state](const rxu::detail::maybe&... mon){ + return state->selector(mon.get()...); + }); + }, + state->out); + if (selectedResult.empty()) { + return; + } + state->out.on_next(selectedResult.get()); + } + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (--state->pendingCompletions == 0) { + state->out.on_completed(); + } + } + ); + } + + template + void on_subscribe(Subscriber scbr) const { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef typename coordinator_type::template get::type output_type; + + struct combine_latest_state_type + : public std::enable_shared_from_this + , public values + { + combine_latest_state_type(values i, coordinator_type coor, output_type oarg) + : values(std::move(i)) + , pendingCompletions(0) + , valuesSet(0) + , coordinator(std::move(coor)) + , out(std::move(oarg)) + { + } + + // on_completed on the output must wait until all the + // subscriptions have received on_completed + mutable int pendingCompletions; + mutable int valuesSet; + mutable tuple_source_value_type latest; + coordinator_type coordinator; + output_type out; + }; + + auto coordinator = initial.coordination.create_coordinator(); + auto selectedDest = on_exception( + [&](){return coordinator.out(scbr);}, + scbr); + if (selectedDest.empty()) { + return; + } + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new combine_latest_state_type(initial, std::move(coordinator), std::forward(selectedDest.get()))); + + subscribe(state, typename rxu::values_from::type()); + } +}; + +template +class combine_latest_factory +{ + typedef typename std::decay::type coordination_type; + typedef typename std::decay::type selector_type; + typedef std::tuple tuple_source_type; + + coordination_type coordination; + selector_type selector; + tuple_source_type sourcen; + + template + auto make(std::tuple source) + -> observable::value_type, combine_latest> { + return observable::value_type, combine_latest>( + combine_latest(coordination, selector, std::move(source))); + } +public: + combine_latest_factory(coordination_type sf, selector_type s, ObservableN... on) + : coordination(std::move(sf)) + , selector(std::move(s)) + , sourcen(std::make_tuple(std::move(on)...)) + { + } + + template + auto operator()(Observable source) + -> decltype(make(std::tuple_cat(std::make_tuple(source), *(tuple_source_type*)nullptr))) { + return make(std::tuple_cat(std::make_tuple(source), sourcen)); + } +}; + +} + +template +auto combine_latest(Coordination sf, Selector s, ObservableN... on) + -> detail::combine_latest_factory { + return detail::combine_latest_factory(std::move(sf), std::move(s), std::move(on)...); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a2adb21..3f42da5 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -511,6 +511,60 @@ public: rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } + template + struct delayed_combine_latest + { + typedef observable::value_type, rxo::detail::combine_latest> type; + }; + + /// combine_latest -> + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. + /// + template + auto combine_latest(Selector&& s, ObservableN... on) const + -> typename std::enable_if::value && !is_observable::value && rxu::all_true::value...>::value, + delayed_combine_latest>::type::type { + return observable::value_type, rxo::detail::combine_latest>( + rxo::detail::combine_latest(identity_one_worker(rxsc::make_current_thread()), std::forward(s), std::make_tuple(*this, on...))); + } + + /// combine_latest -> + /// The coordination is used to synchronize sources from different contexts. + /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. + /// + template + auto combine_latest(Coordination cn, Selector&& s, ObservableN... on) const + -> typename std::enable_if::value && !is_observable::value && rxu::all_true::value...>::value, + delayed_combine_latest>::type::type { + return observable::value_type, rxo::detail::combine_latest>( + rxo::detail::combine_latest(std::move(cn), std::forward(s), std::make_tuple(*this, on...))); + } + + /// combine_latest -> + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. + /// + template + auto combine_latest(ObservableN... on) const + -> typename std::enable_if::value...>::value, + delayed_combine_latest>::type::type { + return observable::value_type, rxo::detail::combine_latest>( + rxo::detail::combine_latest(identity_one_worker(rxsc::make_current_thread()), rxu::pack(), std::make_tuple(*this, on...))); + } + + /// combine_latest -> + /// The coordination is used to synchronize sources from different contexts. + /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. + /// + template + auto combine_latest(Coordination cn, ObservableN... on) const + -> typename std::enable_if::value && rxu::all_true::value...>::value, + delayed_combine_latest>::type::type { + return observable::value_type, rxo::detail::combine_latest>( + rxo::detail::combine_latest(std::move(cn), rxu::pack(), std::make_tuple(*this, on...))); + } + /// multicast -> /// allows connections to the source to be independent of subscriptions /// @@ -658,19 +712,19 @@ public: } template static auto from(Coordination cn) - -> typename std::enable_if::value, + -> typename std::enable_if::value, decltype( rxs::from(std::move(cn)))>::type { return rxs::from(std::move(cn)); } template static auto from(Value0 v0, ValueN... vn) - -> typename std::enable_if::value, + -> typename std::enable_if::value, decltype( rxs::from(v0, vn...))>::type { return rxs::from(v0, vn...); } template static auto from(Coordination cn, Value0 v0, ValueN... vn) - -> typename std::enable_if::value, + -> typename std::enable_if::value, decltype( rxs::from(std::move(cn), v0, vn...))>::type { return rxs::from(std::move(cn), v0, vn...); } diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 08bb9dd..8893abe 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -42,6 +42,7 @@ namespace rxo=operators; #include "operators/rx-flat_map.hpp" #include "operators/rx-concat.hpp" #include "operators/rx-concat_map.hpp" +#include "operators/rx-combine_latest.hpp" #include "operators/rx-multicast.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index e5bdb81..3a3ca30 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -129,6 +129,29 @@ auto apply_to(F f) namespace detail { +struct pack +{ + template + auto operator()(ParamN... pn) + -> decltype(std::make_tuple(std::move(pn)...)) { + return std::make_tuple(std::move(pn)...); + } + template + auto operator()(ParamN... pn) + -> decltype(std::make_tuple(std::move(pn)...)) const { + return std::make_tuple(std::move(pn)...); + } +}; + +} + +inline auto pack() + -> detail::pack { + return detail::pack(); +} + +namespace detail { + template class maybe { diff --git a/Rx/v2/test/operators/combine_latest.cpp b/Rx/v2/test/operators/combine_latest.cpp new file mode 100644 index 0000000..b5181d1 --- /dev/null +++ b/Rx/v2/test/operators/combine_latest.cpp @@ -0,0 +1,88 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages> mo; + typedef rxn::subscription life; + + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + record messages1[] = { + on_next(150, 1), + on_next(215, 2), + on_next(225, 4), + on_completed(230) + }; + auto o1 = sc.make_hot_observable(messages1); + + record messages2[] = { + on_next(150, 1), + on_next(220, 3), + on_next(230, 5), + on_next(235, 6), + on_next(240, 7), + on_completed(250) + }; + auto o2 = sc.make_hot_observable(messages2); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest([](int v2, int v1){return v2 + v1;}, o1); + } + ); + + THEN("the output contains combined ints"){ + record items[] = { + on_next(220, 2 + 3), + on_next(225, 4 + 3), + on_next(230, 4 + 5), + on_next(235, 4 + 6), + on_next(240, 4 + 7), + on_completed(250) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + life items[] = { + subscribe(200, 230) + }; + auto required = rxu::to_vector(items); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 0e5dbf5..4a54645 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -43,6 +43,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp ${V2_TEST_DIR}/sources/defer.cpp + ${V2_TEST_DIR}/operators/combine_latest.cpp ${V2_TEST_DIR}/sources/interval.cpp ${V2_TEST_DIR}/operators/concat.cpp ${V2_TEST_DIR}/operators/merge.cpp -- GitLab From 5e0e2bfde5dcf56bafd3d6a37d0c0680ca039a38 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Jun 2014 23:06:11 -0700 Subject: [PATCH 317/782] fix compilation on windows --- .../src/rxcpp/operators/rx-combine_latest.hpp | 16 ++++++------ Rx/v2/src/rxcpp/rx-util.hpp | 25 +++++++++++++++++-- Rx/v2/test/operators/combine_latest.cpp | 4 ++- 3 files changed, 33 insertions(+), 12 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index 1c9281a..b8c270e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -68,12 +68,8 @@ struct combine_latest : public operator_base - void subscribe(std::shared_ptr state, rxu::values) const { - bool subscribed[] = {(subscribe(state), true)...}; - } template - void subscribe(std::shared_ptr state) const { + void subscribe_one(std::shared_ptr state) const { typedef typename std::tuple_element::type::value_type source_value_type; @@ -111,9 +107,7 @@ struct combine_latest : public operator_basevaluesSet == sizeof... (ObservableN)) { auto selectedResult = on_exception( [&](){ - return rxu::apply(state->latest, [state](const rxu::detail::maybe&... mon){ - return state->selector(mon.get()...); - }); + return rxu::apply(rxu::surely(state->latest), state->selector); }, state->out); if (selectedResult.empty()) { @@ -134,6 +128,10 @@ struct combine_latest : public operator_base + void subscribe_all(std::shared_ptr state, rxu::values) const { + bool subscribed[] = {(subscribe_one(state), true)...}; + } template void on_subscribe(Subscriber scbr) const { @@ -174,7 +172,7 @@ struct combine_latest : public operator_base(new combine_latest_state_type(initial, std::move(coordinator), std::forward(selectedDest.get()))); - subscribe(state, typename rxu::values_from::type()); + subscribe_all(state, typename rxu::values_from::type()); } }; diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 3a3ca30..bb2730a 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -137,8 +137,8 @@ struct pack return std::make_tuple(std::move(pn)...); } template - auto operator()(ParamN... pn) - -> decltype(std::make_tuple(std::move(pn)...)) const { + auto operator()(ParamN... pn) const + -> decltype(std::make_tuple(std::move(pn)...)) { return std::make_tuple(std::move(pn)...); } }; @@ -277,6 +277,27 @@ public: } }; +} + +namespace detail { + struct surely + { + template + auto operator()(T... t) + -> decltype(std::make_tuple(t.get()...)) { + return std::make_tuple(t.get()...); + } + }; +} + +template +inline auto surely(std::tuple tpl) + -> decltype(apply(tpl, detail::surely())) { + return apply(tpl, detail::surely()); +} + +namespace detail { + template class unwinder { diff --git a/Rx/v2/test/operators/combine_latest.cpp b/Rx/v2/test/operators/combine_latest.cpp index b5181d1..8f40d22 100644 --- a/Rx/v2/test/operators/combine_latest.cpp +++ b/Rx/v2/test/operators/combine_latest.cpp @@ -48,7 +48,9 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato auto res = w.start( [&]() { return o2 - .combine_latest([](int v2, int v1){return v2 + v1;}, o1); + .combine_latest([](int v2, int v1){return v2 + v1;}, o1) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); } ); -- GitLab From 44251fbe8b122dbcfd9b92e2edf85514e208884c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 10 Jun 2014 23:14:09 -0700 Subject: [PATCH 318/782] osx compilation fix --- Rx/v2/src/rxcpp/rx-util.hpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index bb2730a..3151fce 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -283,7 +283,12 @@ namespace detail { struct surely { template - auto operator()(T... t) + auto operator()(T... t) + -> decltype(std::make_tuple(t.get()...)) { + return std::make_tuple(t.get()...); + } + template + auto operator()(T... t) const -> decltype(std::make_tuple(t.get()...)) { return std::make_tuple(t.get()...); } @@ -291,7 +296,7 @@ namespace detail { } template -inline auto surely(std::tuple tpl) +inline auto surely(const std::tuple& tpl) -> decltype(apply(tpl, detail::surely())) { return apply(tpl, detail::surely()); } -- GitLab From 6440adb4218f46778f51380f408c6e9ac50f108d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 11 Jun 2014 08:41:09 -0700 Subject: [PATCH 319/782] fix for when sources use the immediate scheduler --- .../src/rxcpp/operators/rx-combine_latest.hpp | 3 +- Rx/v2/test/subscriptions/subscription.cpp | 46 +++++++++++++++++-- 2 files changed, 43 insertions(+), 6 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index b8c270e..f990dc7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -86,7 +86,6 @@ struct combine_latest : public operator_basependingCompletions; // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished @@ -145,7 +144,7 @@ struct combine_latest : public operator_base(finish-start); - std::cout << "loop subscribe : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + std::cout << "loop subscribe map : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + + if (--runs > 0) { + self(); + } + }; + + w.schedule(loop); + } + } +} + +SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][subscribe][long][perf]"){ + const int& subscriptions = static_subscriptions; + GIVEN("a for loop"){ + WHEN("subscribe 100K times"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + int runs = 10; + + auto loop = [&](const rxsc::schedulable& self) { + int c = 0; + int n = 1; + auto start = clock::now(); + for (int i = 0; i < subscriptions; i++) { + rx::observable<>::just(1) + .combine_latest([](int i, int j) { + return i + j; + }, rx::observable<>::just(2)) + .subscribe([&](int i){ + ++c; + }); + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "loop subscribe combine_latest : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; if (--runs > 0) { self(); -- GitLab From ccea4b8b01cb990ee53eb46b0a3654e941108531 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 11 Jun 2014 10:19:27 -0700 Subject: [PATCH 320/782] fix lifetime bug in subject --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index fbcc331..eff91c9 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -31,8 +31,6 @@ class multicast_observer }; }; - struct completer_type; - struct state_type : public std::enable_shared_from_this { @@ -140,9 +138,6 @@ public: void on_next(V&& v) const { if (b->current_generation != b->state->generation) { std::unique_lock guard(b->state->lock); - if (!b->completer) { - return; - } b->current_generation = b->state->generation; b->current_completer = b->completer; } @@ -162,6 +157,7 @@ public: b->state->current = mode::Errored; auto s = b->state->lifetime; auto c = std::move(b->completer); + b->current_completer.reset(); ++b->state->generation; guard.unlock(); if (c) { @@ -180,6 +176,7 @@ public: b->state->current = mode::Completed; auto s = b->state->lifetime; auto c = std::move(b->completer); + b->current_completer.reset(); ++b->state->generation; guard.unlock(); if (c) { -- GitLab From 10d351b2daded687478a0a8e3e8b7f710b1a548b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS OPEN TECH)" Date: Wed, 11 Jun 2014 17:53:18 -0700 Subject: [PATCH 321/782] fix name hiding warnings --- Rx/v2/src/rxcpp/operators/rx-ref_count.hpp | 2 +- Rx/v2/src/rxcpp/rx-notification.hpp | 4 ++-- Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp index 9cc3354..41e4bd9 100644 --- a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -46,7 +46,7 @@ struct ref_count : public operator_base guard.unlock(); o.add( [keepAlive](){ - std::unique_lock guard(keepAlive->lock); + std::unique_lock guard_unsubscribe(keepAlive->lock); if (--keepAlive->subscribers == 0) { keepAlive->connection.unsubscribe(); keepAlive->connection = composite_subscription(); diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index 8e4d27a..bd7f861 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -95,8 +95,8 @@ private: } virtual bool equals(const typename base::type& other) const { bool result = false; - other->accept(make_subscriber(make_observer_dynamic([this, &result](T value) { - result = this->value == value; + other->accept(make_subscriber(make_observer_dynamic([this, &result](T v) { + result = this->value == v; }))); return result; } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 06e81ed..7578272 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -205,9 +205,9 @@ private: // loop until queue is empty for ( - auto when = queue::top().when; - (std::this_thread::sleep_until(when), true); - when = queue::top().when + auto next = queue::top().when; + (std::this_thread::sleep_until(next), true); + next = queue::top().when ) { auto what = queue::top().what; -- GitLab From 06ea43bbc04b4a1a743d3c129a5ba8a9e1254e20 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 11 Jun 2014 23:23:57 -0700 Subject: [PATCH 322/782] add buffer --- Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp | 129 ++++++++++++++++++ Rx/v2/src/rxcpp/rx-notification.hpp | 20 +++ Rx/v2/src/rxcpp/rx-observable.hpp | 16 +++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/src/rxcpp/rx-util.hpp | 6 + Rx/v2/test/operators/buffer.cpp | 78 +++++++++++ projects/CMake/CMakeLists.txt | 1 + 7 files changed, 251 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp create mode 100644 Rx/v2/test/operators/buffer.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp new file mode 100644 index 0000000..5bd0ee4 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp @@ -0,0 +1,129 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_BUFFER_COUNT_HPP) +#define RXCPP_OPERATORS_RX_BUFFER_COUNT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + + +template +struct buffer_count +{ + typedef typename std::decay::type source_value_type; + struct buffer_count_values + { + buffer_count_values(int c, int s) + : count(c) + , skip(s) + { + } + int count; + int skip; + }; + + buffer_count_values initial; + + buffer_count(int count, int skip) + : initial(count, skip) + { + } + + template + struct buffer_count_observer : public buffer_count_values, public observer_base> + { + typedef buffer_count_observer this_type; + typedef observer_base> base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + mutable int cursor; + mutable std::deque> chunks; + + buffer_count_observer(dest_type d, buffer_count_values v) + : buffer_count_values(v) + , dest(std::move(d)) + , cursor(0) + { + } + void on_next(T v) const { + if (cursor++ % this->skip == 0) { + chunks.emplace_back(); + } + for(auto& chunk : chunks) { + chunk.push_back(v); + } + while (!chunks.empty() && chunks.front().size() == this->count) { + dest.on_next(std::move(chunks.front())); + chunks.pop_front(); + } + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + auto done = on_exception( + [&](){ + while (!chunks.empty()) { + dest.on_next(std::move(chunks.front())); + chunks.pop_front(); + } + return true; + }, + dest); + if (done.empty()) { + return; + } + dest.on_completed(); + } + + static subscriber make(dest_type d, buffer_count_values v) { + auto cs = d.get_subscription(); + return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(buffer_count_observer::make(std::move(dest), initial)) { + return buffer_count_observer::make(std::move(dest), initial); + } +}; + +class buffer_count_factory +{ + int count; + int skip; +public: + buffer_count_factory(int c, int s) : count(c), skip(s) {} + template + auto operator()(Observable&& source) + -> decltype(source.lift(buffer_count::type::value_type>(count, skip))) { + return source.lift(buffer_count::type::value_type>(count, skip)); + } +}; + +} + +inline auto buffer(int count) + -> detail::buffer_count_factory { + return detail::buffer_count_factory(count, count); +} +inline auto buffer(int count, int skip) + -> detail::buffer_count_factory { + return detail::buffer_count_factory(count, skip); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index bd7f861..cc4c721 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -56,6 +56,9 @@ struct notification_base virtual void accept(const observer_type& o) const =0; }; +template +std::ostream& operator<< (std::ostream& out, const std::vector& v); + template auto to_stream(std::ostream& os, const T& t, int, int) -> decltype(os << t) { @@ -74,6 +77,23 @@ auto to_stream(std::ostream& os, const T&, ...) return os << ""; } +template +inline std::ostream& operator<< (std::ostream& os, const std::vector& v) { + os << "["; + bool emit = false; + for(auto& i : v) { + if (emit) { + os << ", "; + } else { + emit = true; + } + to_stream(os, i, 0, 0); + } + os << "]"; + return os; +} + + } template diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 3f42da5..f14c0ac 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -325,6 +325,22 @@ public: return lift(rxo::detail::map(std::move(s))); } + /// buffer -> + /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. + /// + auto buffer(int count) const + -> decltype(lift(rxo::detail::buffer_count(count, count))) { + return lift(rxo::detail::buffer_count(count, count)); + } + + /// buffer -> + /// start a new vector every skip items and collect count items from this observable into each vector to emit from the new observable that is returned. + /// + auto buffer(int count, int skip) const + -> decltype(lift(rxo::detail::buffer_count(count, skip))) { + return lift(rxo::detail::buffer_count(count, skip)); + } + template::value> struct merge_result; diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 8893abe..4928940 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -35,6 +35,7 @@ namespace rxo=operators; } #include "operators/rx-lift.hpp" +#include "operators/rx-buffer_count.hpp" #include "operators/rx-subscribe.hpp" #include "operators/rx-filter.hpp" #include "operators/rx-map.hpp" diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 3151fce..31ec1e3 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -37,6 +37,12 @@ std::vector to_vector(const T (&arr) [size]) { return std::vector(std::begin(arr), std::end(arr)); } +template +typename std::enable_if::value, std::vector>::type to_vector(T0 t0, TN... tn) { + T0 arr[] = {t0, tn...}; + return to_vector(arr); +} + template struct values {}; diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp new file mode 100644 index 0000000..a98e03e --- /dev/null +++ b/Rx/v2/test/operators/buffer.cpp @@ -0,0 +1,78 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("buffer count skip less", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + typedef rxsc::test::messages m; + typedef rxsc::test::messages> mv; + typedef rxn::subscription life; + + typedef m::recorded_type record; + auto on_next = m::on_next; + auto on_completed = m::on_completed; + auto subscribe = m::subscribe; + + typedef mv::recorded_type vrecord; + auto von_next = mv::on_next; + auto von_completed = mv::on_completed; + auto vsubscribe = mv::subscribe; + + record messages1[] = { + on_next(150, 1), + on_next(210, 2), + on_next(220, 3), + on_next(230, 4), + on_next(240, 5), + on_completed(250) + }; + auto xs = sc.make_hot_observable(messages1); + + WHEN("group each int with the next 2 ints"){ + + auto res = w.start>( + [&]() { + return xs + .buffer(3, 1) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + vrecord items[] = { + von_next(230, rxu::to_vector(2, 3, 4)), + von_next(240, rxu::to_vector(3, 4, 5)), + von_next(250, rxu::to_vector(4, 5)), + von_next(250, rxu::to_vector(5)), + von_completed(250) + }; + auto required = rxu::to_vector(items); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + life items[] = { + subscribe(200, 250) + }; + auto required = rxu::to_vector(items); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 4a54645..87676b6 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,6 +42,7 @@ add_executable(testbench ${TESTBENCH_SOURCES}) # define the sources of the self test set(V2_TEST_SOURCES ${V2_TEST_DIR}/test.cpp + ${V2_TEST_DIR}/operators/buffer.cpp ${V2_TEST_DIR}/sources/defer.cpp ${V2_TEST_DIR}/operators/combine_latest.cpp ${V2_TEST_DIR}/sources/interval.cpp -- GitLab From 9c9d3fb77cb242a862d1da978a8cc101dcaf663c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 12 Jun 2014 08:51:57 -0700 Subject: [PATCH 323/782] remove v1 from master and update readme also adds one example --- AUTHORS.txt | 9 +- README.md | 106 +- Rx/CPP/.gitattributes | 22 - Rx/CPP/.gitignore | 165 --- Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp | 200 ---- Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h | 91 -- .../MfcTimeFliesLikeAnArrow.cpp | 153 --- .../MfcTimeFliesLikeAnArrow.h | 37 - .../MfcTimeFliesLikeAnArrow.rc | 276 ----- .../MfcTimeFliesLikeAnArrow.vcxproj | 137 --- .../MfcTimeFliesLikeAnArrow.vcxproj.filters | 63 - Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt | 95 -- Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h | 20 - .../res/MfcTimeFliesLikeAnArrow.ico | Bin 67777 -> 0 bytes .../res/MfcTimeFliesLikeAnArrow.rc2 | Bin 830 -> 0 bytes Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp | 9 - Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h | 64 - Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h | 10 - Rx/CPP/RxCpp.sln | 26 - Rx/CPP/license.txt | 15 - Rx/CPP/src/RxCpp.vcxproj | 61 - Rx/CPP/src/RxCpp.vcxproj.filters | 43 - Rx/CPP/src/cpprx/operators/CombineLatest.hpp | 168 --- Rx/CPP/src/cpprx/operators/Concat.hpp | 161 --- Rx/CPP/src/cpprx/operators/ConnectForever.hpp | 22 - Rx/CPP/src/cpprx/operators/Delay.hpp | 79 -- Rx/CPP/src/cpprx/operators/Dematerialize.hpp | 93 -- .../cpprx/operators/DistinctUntilChanged.hpp | 55 - Rx/CPP/src/cpprx/operators/Empty.hpp | 74 -- Rx/CPP/src/cpprx/operators/ForEach.hpp | 49 - Rx/CPP/src/cpprx/operators/GroupBy.hpp | 102 -- Rx/CPP/src/cpprx/operators/Interval.hpp | 62 - Rx/CPP/src/cpprx/operators/Iterate.hpp | 86 -- Rx/CPP/src/cpprx/operators/Materialize.hpp | 87 -- Rx/CPP/src/cpprx/operators/Merge.hpp | 121 -- Rx/CPP/src/cpprx/operators/Multicast.hpp | 20 - Rx/CPP/src/cpprx/operators/Never.hpp | 22 - .../src/cpprx/operators/ObserveOnObserver.hpp | 53 - Rx/CPP/src/cpprx/operators/Publish.hpp | 34 - Rx/CPP/src/cpprx/operators/Random.hpp | 70 -- Rx/CPP/src/cpprx/operators/Range.hpp | 65 -- Rx/CPP/src/cpprx/operators/RefCount.hpp | 102 -- Rx/CPP/src/cpprx/operators/Return.hpp | 78 -- Rx/CPP/src/cpprx/operators/Scan.hpp | 127 -- Rx/CPP/src/cpprx/operators/Select.hpp | 89 -- Rx/CPP/src/cpprx/operators/SelectMany.hpp | 118 -- Rx/CPP/src/cpprx/operators/Skip.hpp | 132 --- Rx/CPP/src/cpprx/operators/Subscribe.hpp | 27 - .../cpprx/operators/SubscribeOnObservable.hpp | 35 - Rx/CPP/src/cpprx/operators/Take.hpp | 173 --- Rx/CPP/src/cpprx/operators/Throttle.hpp | 97 -- Rx/CPP/src/cpprx/operators/Throw.hpp | 104 -- Rx/CPP/src/cpprx/operators/ToAsync.hpp | 48 - .../src/cpprx/operators/ToStdCollection.hpp | 44 - Rx/CPP/src/cpprx/operators/Using.hpp | 112 -- Rx/CPP/src/cpprx/operators/Where.hpp | 86 -- Rx/CPP/src/cpprx/operators/Zip.hpp | 223 ---- Rx/CPP/src/cpprx/rx-base.hpp | 1029 ----------------- Rx/CPP/src/cpprx/rx-includes.hpp | 100 -- Rx/CPP/src/cpprx/rx-operators.hpp | 1018 ---------------- Rx/CPP/src/cpprx/rx-scheduler.hpp | 947 --------------- Rx/CPP/src/cpprx/rx-util.hpp | 509 -------- Rx/CPP/src/cpprx/rx-windows.hpp | 282 ----- Rx/CPP/src/cpprx/rx-winrt.hpp | 667 ----------- Rx/CPP/src/cpprx/rx.hpp | 587 ---------- Rx/CPP/test/operators/Merge.cpp | 60 - Rx/CPP/test/operators/Publish.cpp | 111 -- Rx/CPP/test/operators/Return.cpp | 119 -- Rx/CPP/test/operators/Select.cpp | 181 --- Rx/CPP/test/operators/SelectMany.cpp | 279 ----- Rx/CPP/test/operators/Where.cpp | 389 ------- Rx/CPP/test/test.cpp | 2 - Rx/CPP/testbench/data.txt | 655 ----------- Rx/CPP/testbench/testbench.cpp | 652 ----------- Rx/CPP/testbench/testbench.vcxproj | 93 -- Rx/CPP/testbench/testbench.vcxproj.filters | 22 - Rx/v2/examples/pythagorian/main.cpp | 50 + Rx/v2/test/operators/flat_map.cpp | 2 +- projects/CMake/CMakeLists.txt | 76 +- projects/nuget/rxcpp.autoconfig | 4 +- 80 files changed, 190 insertions(+), 12264 deletions(-) delete mode 100644 Rx/CPP/.gitattributes delete mode 100644 Rx/CPP/.gitignore delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.rc2 delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h delete mode 100644 Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h delete mode 100644 Rx/CPP/RxCpp.sln delete mode 100644 Rx/CPP/license.txt delete mode 100644 Rx/CPP/src/RxCpp.vcxproj delete mode 100644 Rx/CPP/src/RxCpp.vcxproj.filters delete mode 100644 Rx/CPP/src/cpprx/operators/CombineLatest.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Concat.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/ConnectForever.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Delay.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Dematerialize.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Empty.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/ForEach.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/GroupBy.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Interval.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Iterate.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Materialize.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Merge.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Multicast.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Never.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Publish.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Random.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Range.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/RefCount.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Return.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Scan.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Select.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/SelectMany.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Skip.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Subscribe.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Take.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Throttle.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Throw.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/ToAsync.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/ToStdCollection.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Using.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Where.hpp delete mode 100644 Rx/CPP/src/cpprx/operators/Zip.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-base.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-includes.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-operators.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-scheduler.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-util.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-windows.hpp delete mode 100644 Rx/CPP/src/cpprx/rx-winrt.hpp delete mode 100644 Rx/CPP/src/cpprx/rx.hpp delete mode 100644 Rx/CPP/test/operators/Merge.cpp delete mode 100644 Rx/CPP/test/operators/Publish.cpp delete mode 100644 Rx/CPP/test/operators/Return.cpp delete mode 100644 Rx/CPP/test/operators/Select.cpp delete mode 100644 Rx/CPP/test/operators/SelectMany.cpp delete mode 100644 Rx/CPP/test/operators/Where.cpp delete mode 100644 Rx/CPP/test/test.cpp delete mode 100644 Rx/CPP/testbench/data.txt delete mode 100644 Rx/CPP/testbench/testbench.cpp delete mode 100644 Rx/CPP/testbench/testbench.vcxproj delete mode 100644 Rx/CPP/testbench/testbench.vcxproj.filters create mode 100644 Rx/v2/examples/pythagorian/main.cpp diff --git a/AUTHORS.txt b/AUTHORS.txt index 160efcc..7da61e0 100644 --- a/AUTHORS.txt +++ b/AUTHORS.txt @@ -2,9 +2,9 @@ List of contributors to the Rx libraries Rx and Ix.NET: Wes Dyer -Jeffrey van Gogh -Matthew Podwysocki -Bart de Smet +Jeffrey van Gogh +Matthew Podwysocki +Bart de Smet Danny van Velzen Erik Meijer Brian Beckman @@ -24,7 +24,7 @@ Erik Meijer Tx: Georgi Chkodrov -Bart de Smet +Bart de Smet Aaron Lahman Erik Meijer Brian Grunkemeyer @@ -38,3 +38,4 @@ Zach Kramer Rx++ and Ix++: Aaron Lahman +Kirk Shoop diff --git a/README.md b/README.md index 122be88..9140c1d 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ Rxcpp Build status [![Build Status](https://travis-ci.org/Reactive-Extensions/Rx * Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. * RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. -* Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. +* RxCpp: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++. # Interactive Extensions * Ix: The Interactive Extensions (Ix) is a .NET library which extends LINQ to Objects to provide many of the operators available in Rx but targeted for IEnumerable. @@ -15,8 +15,110 @@ Rxcpp Build status [![Build Status](https://travis-ci.org/Reactive-Extensions/Rx * Tx: a set of code samples showing how to use LINQ to events, such as real-time standing queries and queries on past history from trace and log files, which targets ETW, Windows Event Logs and SQL Server Extended Events. * LINQ2Charts: an example for Rx bindings. Similar to existing APIs like LINQ to XML, it allows developers to use LINQ to create/change/update charts in an easy way and avoid having to deal with XML or other underneath data structures. We would love to see more Rx bindings like this one. +#Building RxCpp + +RxCpp is regularly tested on OSX and Windows. +RxCpp is regularly built with Clang and VC +RxCpp depends on the latest compiler releases. +RxCpp does not compile with gcc at this time. Contributions are welcome. + +RxCpp uses CMake to create build files for several platforms and IDE's + +```cmake projects\CMake``` + +This will create the default build for the platform. + +##Ide builds +###XCode +```cmake -G"Xcode" projects\CMake``` + +###Visual Studio 13 +```cmake -G"Visual Studio 12" projects\CMake``` +Then open in VC2013 and upgrade to the 2013 toolset + +##makefile builds + +##OSX +``` +cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo projects\CMake +make +``` + +##Windows +``` +cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo projects\CMake +nmake +``` + +The build only produces a test binary. + +#Running tests + +You can use the CMake test runner ```ctest``` +You can run the test binary directly ```rxcppv2_test``` +Tests can be selected by name or tag +Example of by-tag + +```rxcppv2_test [perf]``` + +#Using RxCpp +Add ```Rx/v2/src``` to the include paths + +``` +#include "rxcpp/rx.hpp" +// create alias' to simplify code +// these are owned by the user so that +// conflicts can be managed by the user. +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; + +// At this time, RxCpp will fail to compile if the contents +// of the std namespace are merged into the global namespace +// DO NOT USE: 'using namespace std;' + +#ifdef UNICODE +int wmain(int argc, wchar_t** argv) +#else +int main(int argc, char** argv) +#endif +{ + int c = 0; + + auto triples = + rx::observable<>::range(1) + .concat_map( + [&c](int z){ + return rx::observable<>::range(1, z) + .concat_map( + [=, &c](int x){ + return rx::observable<>::range(x, z) + .filter([=, &c](int y){++c; return x*x + y*y == z*z;}) + .map([=](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}); + + int ct = 0; + + triples + .take(100) + .subscribe(rxu::apply_to([&ct](int x,int y,int z){ + ++ct; + })); + + std::cout << "concat_map pythagorian range : " << c << " filtered to, " << ct << " triplets" << std::endl; + + return 0; +} +``` + #Contributing Code Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source. -You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Download the Contributor License Agreement (CLA). Please fill in, sign, scan and email it to msopentech-cla@microsoft.com. +You will need to submit a Contributor License Agreement form before submitting your pull request. This needs to only be done once for any Microsoft OSS project. Fill in the [Contributor License Agreement](https://cla.msopentech.com/) (CLA). diff --git a/Rx/CPP/.gitattributes b/Rx/CPP/.gitattributes deleted file mode 100644 index 412eeda..0000000 --- a/Rx/CPP/.gitattributes +++ /dev/null @@ -1,22 +0,0 @@ -# Auto detect text files and perform LF normalization -* text=auto - -# Custom for Visual Studio -*.cs diff=csharp -*.sln merge=union -*.csproj merge=union -*.vbproj merge=union -*.fsproj merge=union -*.dbproj merge=union - -# Standard to msysgit -*.doc diff=astextplain -*.DOC diff=astextplain -*.docx diff=astextplain -*.DOCX diff=astextplain -*.dot diff=astextplain -*.DOT diff=astextplain -*.pdf diff=astextplain -*.PDF diff=astextplain -*.rtf diff=astextplain -*.RTF diff=astextplain diff --git a/Rx/CPP/.gitignore b/Rx/CPP/.gitignore deleted file mode 100644 index 4822a56..0000000 --- a/Rx/CPP/.gitignore +++ /dev/null @@ -1,165 +0,0 @@ -################# -## Eclipse -################# - -*.pydevproject -.project -.metadata -bin/ -tmp/ -*.tmp -*.bak -*.swp -*~.nib -local.properties -.classpath -.settings/ -.loadpath - -# External tool builders -.externalToolBuilders/ - -# Locally stored "Eclipse launch configurations" -*.launch - -# CDT-specific -.cproject - -# PDT-specific -.buildpath - - -################# -## Visual Studio -################# - -## Ignore Visual Studio temporary files, build results, and -## files generated by popular Visual Studio add-ons. - -# User-specific files -*.suo -*.user -*.sln.docstates - -# Build results -[Dd]ebug/ -[Rr]elease/ -*_i.c -*_p.c -*.ilk -*.meta -*.obj -*.pch -*.pdb -*.pgc -*.pgd -*.rsp -*.sbr -*.tlb -*.tli -*.tlh -*.tmp -*.vspscc -.builds -*.dotCover - -## TODO: If you have NuGet Package Restore enabled, uncomment this -#packages/ - -# Visual C++ cache files -ipch/ -*.aps -*.ncb -*.opensdf -*.sdf - -# Visual Studio profiler -*.psess -*.vsp - -# ReSharper is a .NET coding add-in -_ReSharper* - -# Installshield output folder -[Ee]xpress - -# DocProject is a documentation generator add-in -DocProject/buildhelp/ -DocProject/Help/*.HxT -DocProject/Help/*.HxC -DocProject/Help/*.hhc -DocProject/Help/*.hhk -DocProject/Help/*.hhp -DocProject/Help/Html2 -DocProject/Help/html - -# Click-Once directory -publish - -# Others -[Bb]in -[Oo]bj -sql -TestResults -*.Cache -ClientBin -stylecop.* -~$* -*.dbmdl -Generated_Code #added for RIA/Silverlight projects - -# Backup & report files from converting an old project file to a newer -# Visual Studio version. Backup files are not needed, because we have git ;-) -_UpgradeReport_Files/ -Backup*/ -UpgradeLog*.XML - - - -############ -## Windows -############ - -# Windows image file caches -Thumbs.db - -# Folder config file -Desktop.ini - - -############# -## Python -############# - -*.py[co] - -# Packages -*.egg -*.egg-info -dist -build -eggs -parts -bin -var -sdist -develop-eggs -.installed.cfg - -# Installer logs -pip-log.txt - -# Unit test / coverage reports -.coverage -.tox - -#Translations -*.mo - -#Mr Developer -.mr.developer.cfg - -# Mac crap -.DS_Store - -a.out diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp deleted file mode 100644 index 4fc260d..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.cpp +++ /dev/null @@ -1,200 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - - -// MainFrm.cpp : implementation of the CMainFrame class -// - -#include "stdafx.h" -#include "MfcTimeFliesLikeAnArrow.h" - -#include "MainFrm.h" - -#ifdef _DEBUG -#define new DEBUG_NEW -#endif - -// CMainFrame - -IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd) - -BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) - ON_WM_CREATE() -// ON_WM_SETFOCUS() - ON_WM_CLOSE() - ON_WM_MOUSEMOVE() - ON_WM_PAINT() -END_MESSAGE_MAP() - -static UINT indicators[] = -{ - ID_SEPARATOR, // status line indicator - ID_INDICATOR_CAPS, - ID_INDICATOR_NUM, - ID_INDICATOR_SCRL, -}; - -// CMainFrame construction/destruction - -CMainFrame::CMainFrame() -{ - // TODO: add member initialization code here -} - -CMainFrame::~CMainFrame() -{ -} - - -// inspired by: http://minirx.codeplex.com/ -void CMainFrame::UserInit() -{ - auto worker = std::make_shared(); - auto mainFormScheduler = std::make_shared(); - auto mouseMove = BindEventToObservable(mouseMoveEvent); - - // set up labels and query - auto msg = L"Time flies like an arrow"; - -#if LABEL_EXPRESSION_TRACING - auto start = worker->Now(); - auto ms = std::chrono::milliseconds(1); -#endif - - for (int i = 0; msg[i]; ++i) - { - auto label = CreateLabelFromLetter(msg[i], this); - - // note: distinct_until_changed is necessary; while - // Winforms filters duplicate mouse moves, - // user32 doesn't filter this for you: http://blogs.msdn.com/b/oldnewthing/archive/2003/10/01/55108.aspx - - auto s = rxcpp::from(mouseMove) - .select([=](MouseMoveEventValue e) { - auto now = worker->Now(); -#if LABEL_EXPRESSION_TRACING - {std::wstringstream out; - out << L"input index: " << i << L", ms: " << ((now - start) / ms) - << L", x: " << e.point.x << L", y: " << e.point.y - << L", x: " << e.point.x+20*i << L", y: " << e.point.y-20 << std::endl; - OutputDebugString(out.str().c_str());} -#endif - return std::make_tuple(now, e.point); }) - .distinct_until_changed() - .delay(std::chrono::milliseconds(i * 100 + 1), worker) -#if LABEL_EXPRESSION_TRACING - .select(rxcpp::MakeTupleDispatch([=](rxcpp::Scheduler::clock::time_point time, CPoint point) { - {std::wstringstream out; - out << L"delayed index: " << i << L", ms: " << ((time - start) / ms) - << L", x: " << point.x << L", y: " << point.y - << L", x: " << point.x+20*i << L", y: " << point.y-20 << std::endl; - OutputDebugString(out.str().c_str());} - return std::make_tuple(time, point);;})) -#endif - .observe_on(mainFormScheduler) - .subscribe(rxcpp::MakeTupleDispatch([=](rxcpp::Scheduler::clock::time_point time, CPoint point) - { -#if LABEL_EXPRESSION_TRACING - {std::wstringstream out; - out << L"observed index: " << i << L", ms: " << ((time - start) / ms) - << L", x: " << point.x << L", y: " << point.y - << L", x: " << point.x+20*i << L", y: " << point.y-20 << std::endl; - OutputDebugString(out.str().c_str());} -#endif - label->SetWindowPos(nullptr, point.x+20*i, point.y-20, 20, 30, SWP_NOOWNERZORDER); - label->Invalidate(); - - // repaint early, for fluid animation - //label->UpdateWindow(); - this->UpdateWindow(); - })); - - composableDisposable.Add(std::move(s)); - } -} - -void CMainFrame::OnClose() -{ - // shutdown subscription. - composableDisposable.Dispose(); - - CFrameWnd::OnClose(); -} - - -int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) -{ - if (CFrameWnd::OnCreate(lpCreateStruct) == -1) - return -1; - - if (!m_wndStatusBar.Create(this)) - { - TRACE0("Failed to create status bar\n"); - return -1; // fail to create - } - m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT)); - - UserInit(); - - return 0; -} - -BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) -{ - if( !CFrameWnd::PreCreateWindow(cs) ) - return FALSE; - - cs.dwExStyle &= ~WS_EX_CLIENTEDGE; - cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS, ::LoadCursor(NULL, IDC_ARROW)); - return TRUE; -} - -// CMainFrame diagnostics - -#ifdef _DEBUG -void CMainFrame::AssertValid() const -{ - CFrameWnd::AssertValid(); -} - -void CMainFrame::Dump(CDumpContext& dc) const -{ - CFrameWnd::Dump(dc); -} -#endif //_DEBUG - - -// CMainFrame message handlers - -void CMainFrame::OnSetFocus(CWnd* /*pOldWnd*/) -{ - // forward focus to the view window - //m_wndView.SetFocus(); -} - -BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) -{ - // let the view have first crack at the command - //if (m_wndView.OnCmdMsg(nID, nCode, pExtra, pHandlerInfo)) - // return TRUE; - - // otherwise, do default handling - return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo); -} - -void CMainFrame::OnMouseMove(UINT nFlags, CPoint point) -{ - MouseMoveEventValue v = {nFlags, point}; - this->mouseMoveEvent(v); -} - -void CMainFrame::OnPaint( ) -{ - CPaintDC dc(this); // device context for painting - - RECT rc; - this->GetClientRect(&rc); - CBrush brush; - brush.CreateSolidBrush(RGB(240,240,240)); - dc.FillRect(&rc, &brush); -} - diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h deleted file mode 100644 index 040bc7d..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MainFrm.h +++ /dev/null @@ -1,91 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - - -// MainFrm.h : interface of the CMainFrame class -// - -#pragma once - - -template -static std::shared_ptr> - BindEventToObservable(std::function& event) -{ - auto eSubject = rxcpp::CreateSubject(); - event = [=](const T& eventValue) { - eSubject->OnNext(eventValue); - }; - return eSubject; -} - -inline CStatic* CreateLabelFromLetter(wchar_t c, CWnd* parent) -{ - CStatic* label; - label = new CStatic(); - - RECT r = { 0, 0, }; - r.right = r.left+20; - r.bottom = r.top + 30; - - auto message = new std::wstring(&c, &c+1); - label->Create( - message->c_str(), - WS_CHILD | WS_VISIBLE, - r, - parent); - return label; -} - -class CMainFrame : public CFrameWnd -{ - -public: - CMainFrame(); -protected: - DECLARE_DYNAMIC(CMainFrame) - -// Attributes -public: - -// Operations -public: - -// Overrides -public: - virtual BOOL PreCreateWindow(CREATESTRUCT& cs); - virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo); - -// Implementation -public: - virtual ~CMainFrame(); -#ifdef _DEBUG - virtual void AssertValid() const; - virtual void Dump(CDumpContext& dc) const; -#endif - -protected: // control bar embedded members - CStatusBar m_wndStatusBar; - - struct MouseMoveEventValue - { - UINT nFlags; - CPoint point; - }; - - std::function mouseMoveEvent; - -// Generated message map functions -protected: - afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); - afx_msg void OnSetFocus(CWnd *pOldWnd); - afx_msg void OnClose(); - afx_msg void OnMouseMove(UINT nFlags, CPoint point); - afx_msg void OnPaint( ); - - DECLARE_MESSAGE_MAP() - - void UserInit(); - rxcpp::ComposableDisposable composableDisposable; -}; - - diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp deleted file mode 100644 index 59c726a..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.cpp +++ /dev/null @@ -1,153 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -// MfcTimeFliesLikeAnArrow.cpp : Defines the class behaviors for the application. -// - -#include "stdafx.h" -#include "afxwinappex.h" -#include "afxdialogex.h" -#include "MfcTimeFliesLikeAnArrow.h" -#include "MainFrm.h" - - -#ifdef _DEBUG -#define new DEBUG_NEW -#endif - - -// CMfcTimeFliesLikeAnArrowApp - -BEGIN_MESSAGE_MAP(CMfcTimeFliesLikeAnArrowApp, CWinApp) - ON_COMMAND(ID_APP_ABOUT, &CMfcTimeFliesLikeAnArrowApp::OnAppAbout) -END_MESSAGE_MAP() - - -// CMfcTimeFliesLikeAnArrowApp construction - -CMfcTimeFliesLikeAnArrowApp::CMfcTimeFliesLikeAnArrowApp() -{ - // support Restart Manager - m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART; -#ifdef _MANAGED - // If the application is built using Common Language Runtime support (/clr): - // 1) This additional setting is needed for Restart Manager support to work properly. - // 2) In your project, you must add a reference to System.Windows.Forms in order to build. - System::Windows::Forms::Application::SetUnhandledExceptionMode(System::Windows::Forms::UnhandledExceptionMode::ThrowException); -#endif - - // TODO: replace application ID string below with unique ID string; recommended - // format for string is CompanyName.ProductName.SubProduct.VersionInformation - SetAppID(_T("MfcTimeFliesLikeAnArrow.AppID.NoVersion")); - - // TODO: add construction code here, - // Place all significant initialization in InitInstance -} - -// The one and only CMfcTimeFliesLikeAnArrowApp object - -CMfcTimeFliesLikeAnArrowApp theApp; - - -// CMfcTimeFliesLikeAnArrowApp initialization - -BOOL CMfcTimeFliesLikeAnArrowApp::InitInstance() -{ - // InitCommonControlsEx() is required on Windows XP if an application - // manifest specifies use of ComCtl32.dll version 6 or later to enable - // visual styles. Otherwise, any window creation will fail. - INITCOMMONCONTROLSEX InitCtrls; - InitCtrls.dwSize = sizeof(InitCtrls); - // Set this to include all the common control classes you want to use - // in your application. - InitCtrls.dwICC = ICC_WIN95_CLASSES; - InitCommonControlsEx(&InitCtrls); - - CWinApp::InitInstance(); - - - EnableTaskbarInteraction(FALSE); - - // AfxInitRichEdit2() is required to use RichEdit control - // AfxInitRichEdit2(); - - // Standard initialization - // If you are not using these features and wish to reduce the size - // of your final executable, you should remove from the following - // the specific initialization routines you do not need - // Change the registry key under which our settings are stored - // TODO: You should modify this string to be something appropriate - // such as the name of your company or organization - SetRegistryKey(_T("Local AppWizard-Generated Applications")); - - - // To create the main window, this code creates a new frame window - // object and then sets it as the application's main window object - CMainFrame* pFrame = new CMainFrame; - if (!pFrame) - return FALSE; - m_pMainWnd = pFrame; - // create and load the frame with its resources - pFrame->LoadFrame(IDR_MAINFRAME, - WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL, - NULL); - - - - - - // The one and only window has been initialized, so show and update it - pFrame->ShowWindow(SW_SHOW); - pFrame->UpdateWindow(); - return TRUE; -} - -int CMfcTimeFliesLikeAnArrowApp::ExitInstance() -{ - //TODO: handle additional resources you may have added - return CWinApp::ExitInstance(); -} - -// CMfcTimeFliesLikeAnArrowApp message handlers - - -// CAboutDlg dialog used for App About - -class CAboutDlg : public CDialogEx -{ -public: - CAboutDlg(); - -// Dialog Data - enum { IDD = IDD_ABOUTBOX }; - -protected: - virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support - -// Implementation -protected: - DECLARE_MESSAGE_MAP() -}; - -CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD) -{ -} - -void CAboutDlg::DoDataExchange(CDataExchange* pDX) -{ - CDialogEx::DoDataExchange(pDX); -} - -BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx) -END_MESSAGE_MAP() - -// App command to run the dialog -void CMfcTimeFliesLikeAnArrowApp::OnAppAbout() -{ - CAboutDlg aboutDlg; - aboutDlg.DoModal(); -} - -// CMfcTimeFliesLikeAnArrowApp message handlers - - - diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h deleted file mode 100644 index b13b068..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.h +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - - -// MfcTimeFliesLikeAnArrow.h : main header file for the MfcTimeFliesLikeAnArrow application -// -#pragma once - -#ifndef __AFXWIN_H__ - #error "include 'stdafx.h' before including this file for PCH" -#endif - -#include "resource.h" // main symbols - - -// CMfcTimeFliesLikeAnArrowApp: -// See MfcTimeFliesLikeAnArrow.cpp for the implementation of this class -// - -class CMfcTimeFliesLikeAnArrowApp : public CWinApp -{ -public: - CMfcTimeFliesLikeAnArrowApp(); - - -// Overrides -public: - virtual BOOL InitInstance(); - virtual int ExitInstance(); - -// Implementation - -public: - afx_msg void OnAppAbout(); - DECLARE_MESSAGE_MAP() -}; - -extern CMfcTimeFliesLikeAnArrowApp theApp; diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc deleted file mode 100644 index 928bb2f..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.rc +++ /dev/null @@ -1,276 +0,0 @@ -//Microsoft Visual C++ generated resource script. -// -#include "resource.h" - -#define APSTUDIO_READONLY_SYMBOLS -///////////////////////////////////////////////////////////////////////////// -// -// Generated from the TEXTINCLUDE 2 resource. -// -#ifndef APSTUDIO_INVOKED -#include "targetver.h" -#endif -#include "afxres.h" -#include "verrsrc.h" - -///////////////////////////////////////////////////////////////////////////// -#undef APSTUDIO_READONLY_SYMBOLS - -#ifdef APSTUDIO_INVOKED - -///////////////////////////////////////////////////////////////////////////// -// -// TEXTINCLUDE -// - -1 TEXTINCLUDE -BEGIN - "resource.h\0" -END - -2 TEXTINCLUDE -BEGIN - "#ifndef APSTUDIO_INVOKED\r\n" - "#include ""targetver.h""\r\n" - "#endif\r\n" - "#include ""afxres.h""\r\n" - "#include ""verrsrc.h""\r\n" - "\0" -END - -3 TEXTINCLUDE -BEGIN - "#define _AFX_NO_OLE_RESOURCES\r\n" - "#define _AFX_NO_TRACKER_RESOURCES\r\n" - "#define _AFX_NO_PROPERTY_RESOURCES\r\n" - "\r\n" - "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" - "LANGUAGE 9, 1\r\n" - "#include ""res\\MfcTimeFliesLikeAnArrow.rc2"" // non-Microsoft Visual C++ edited resources\r\n" - "#include ""afxres.rc"" // Standard components\r\n" - "#endif\r\n" - "\0" -END - -#endif // APSTUDIO_INVOKED - - -///////////////////////////////////////////////////////////////////////////// -// -// Icon -// - -// Icon with lowest ID value placed first to ensure application icon -// remains consistent on all systems. - -#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) -LANGUAGE 9, 1 -IDR_MAINFRAME ICON "res\\MfcTimeFliesLikeAnArrow.ico" -#endif -#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) -LANGUAGE 9, 1 - -///////////////////////////////////////////////////////////////////////////// -// -// Menu -// - -IDR_MAINFRAME MENU -BEGIN - POPUP "&File" - BEGIN - MENUITEM "E&xit", ID_APP_EXIT - END - POPUP "&Edit" - BEGIN - MENUITEM "&Undo\tCtrl+Z", ID_EDIT_UNDO - MENUITEM SEPARATOR - MENUITEM "Cu&t\tCtrl+X", ID_EDIT_CUT - MENUITEM "&Copy\tCtrl+C", ID_EDIT_COPY - MENUITEM "&Paste\tCtrl+V", ID_EDIT_PASTE - END - POPUP "&View" - BEGIN - MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR - END - POPUP "&Help" - BEGIN - MENUITEM "&About MfcTimeFliesLikeAnArrow...", ID_APP_ABOUT - END -END - - - -///////////////////////////////////////////////////////////////////////////// -// -// Accelerator -// - -IDR_MAINFRAME ACCELERATORS -BEGIN - "C", ID_EDIT_COPY, VIRTKEY,CONTROL,NOINVERT - "V", ID_EDIT_PASTE, VIRTKEY,CONTROL,NOINVERT - VK_BACK, ID_EDIT_UNDO, VIRTKEY,ALT,NOINVERT - VK_DELETE, ID_EDIT_CUT, VIRTKEY,SHIFT,NOINVERT - VK_F6, ID_NEXT_PANE, VIRTKEY ,NOINVERT - VK_F6, ID_PREV_PANE, VIRTKEY,SHIFT,NOINVERT - VK_INSERT, ID_EDIT_COPY, VIRTKEY,CONTROL,NOINVERT - VK_INSERT, ID_EDIT_PASTE, VIRTKEY,SHIFT,NOINVERT - "X", ID_EDIT_CUT, VIRTKEY,CONTROL,NOINVERT - "Z", ID_EDIT_UNDO, VIRTKEY,CONTROL,NOINVERT -END - - - - -///////////////////////////////////////////////////////////////////////////// -// -// Dialog -// - -IDD_ABOUTBOX DIALOGEX 0, 0, 170, 62 -STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU -CAPTION "About MfcTimeFliesLikeAnArrow" -FONT 8, "MS Shell Dlg" -BEGIN - ICON IDR_MAINFRAME,IDC_STATIC,14,14,21,20 - LTEXT "MfcTimeFliesLikeAnArrow, Version 1.0",IDC_STATIC,42,14,114,8,SS_NOPREFIX - LTEXT "Copyright (C) 2012",IDC_STATIC,42,26,114,8 - DEFPUSHBUTTON "OK",IDOK,113,41,50,14,WS_GROUP -END - - - -///////////////////////////////////////////////////////////////////////////// -// -// Version -// - -VS_VERSION_INFO VERSIONINFO - FILEVERSION 1,0,0,1 - PRODUCTVERSION 1,0,0,1 - FILEFLAGSMASK VS_FFI_FILEFLAGSMASK -#ifdef _DEBUG - FILEFLAGS VS_FF_DEBUG -#else - FILEFLAGS 0x0L -#endif - FILEOS VOS_NT_WINDOWS32 - FILETYPE VFT_APP - FILESUBTYPE VFT2_UNKNOWN -BEGIN - BLOCK "StringFileInfo" - BEGIN - BLOCK "040904B0" - BEGIN - VALUE "CompanyName", "TODO: " - VALUE "FileDescription", "MfcTimeFliesLikeAnArrow" - VALUE "FileVersion", "1.0.0.1" - VALUE "InternalName", "MfcTimeFliesLikeAnArrow.exe" - VALUE "LegalCopyright", "TODO: (c) . All rights reserved." - VALUE "OriginalFilename","MfcTimeFliesLikeAnArrow.exe" - VALUE "ProductName", "TODO: " - VALUE "ProductVersion", "1.0.0.1" - END - END - BLOCK "VarFileInfo" - BEGIN - VALUE "Translation", 0x0409, 1200 - END -END - -///////////////////////////////////////////////////////////////////////////// -// -// DESIGNINFO -// - -#ifdef APSTUDIO_INVOKED -GUIDELINES DESIGNINFO -BEGIN - IDD_ABOUTBOX, DIALOG - BEGIN - LEFTMARGIN, 7 - RIGHTMARGIN, 163 - TOPMARGIN, 7 - BOTTOMMARGIN, 55 - END -END -#endif // APSTUDIO_INVOKED - -///////////////////////////////////////////////////////////////////////////// -// -// String Table -// - -STRINGTABLE -BEGIN -// Non-mac-targeting apps remove the two extra substrings - IDR_MAINFRAME "MfcTimeFliesLikeAnArrow" -END -STRINGTABLE -BEGIN - AFX_IDS_APP_TITLE "MfcTimeFliesLikeAnArrow" - AFX_IDS_IDLEMESSAGE "Ready" -END -STRINGTABLE -BEGIN - ID_INDICATOR_EXT "EXT" - ID_INDICATOR_CAPS "CAP" - ID_INDICATOR_NUM "NUM" - ID_INDICATOR_SCRL "SCRL" - ID_INDICATOR_OVR "OVR" - ID_INDICATOR_REC "REC" -END -STRINGTABLE -BEGIN - ID_APP_ABOUT "Display program information, version number and copyright\nAbout" - ID_APP_EXIT "Quit the application; prompts to save documents\nExit" - ID_NEXT_PANE "Switch to the next window pane\nNext Pane" - ID_PREV_PANE "Switch back to the previous window pane\nPrevious Pane" - ID_WINDOW_SPLIT "Split the active window into panes\nSplit" - ID_EDIT_CLEAR "Erase the selection\nErase" - ID_EDIT_CLEAR_ALL "Erase everything\nErase All" - ID_EDIT_COPY "Copy the selection and put it on the Clipboard\nCopy" - ID_EDIT_CUT "Cut the selection and put it on the Clipboard\nCut" - ID_EDIT_FIND "Find the specified text\nFind" - ID_EDIT_PASTE "Insert Clipboard contents\nPaste" - ID_EDIT_REPEAT "Repeat the last action\nRepeat" - ID_EDIT_REPLACE "Replace specific text with different text\nReplace" - ID_EDIT_SELECT_ALL "Select the entire document\nSelect All" - ID_EDIT_UNDO "Undo the last action\nUndo" - ID_EDIT_REDO "Redo the previously undone action\nRedo" - ID_VIEW_STATUS_BAR "Show or hide the status bar\nToggle Status Bar" -END - -STRINGTABLE -BEGIN - AFX_IDS_SCSIZE "Change the window size" - AFX_IDS_SCMOVE "Change the window position" - AFX_IDS_SCMINIMIZE "Reduce the window to an icon" - AFX_IDS_SCMAXIMIZE "Enlarge the window to full size" - AFX_IDS_SCNEXTWINDOW "Switch to the next document window" - AFX_IDS_SCPREVWINDOW "Switch to the previous document window" - AFX_IDS_SCCLOSE "Close the active window and prompts to save the documents" - AFX_IDS_SCRESTORE "Restore the window to normal size" - AFX_IDS_SCTASKLIST "Activate Task List" -END - - -#endif - -#ifndef APSTUDIO_INVOKED -///////////////////////////////////////////////////////////////////////////// -// -// Generated from the TEXTINCLUDE 3 resource. -// - -#define _AFX_NO_OLE_RESOURCES -#define _AFX_NO_TRACKER_RESOURCES -#define _AFX_NO_PROPERTY_RESOURCES - -#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) -LANGUAGE 9, 1 -#include "res\\MfcTimeFliesLikeAnArrow.rc2" // non-Microsoft Visual C++ edited resources -#include "afxres.rc" // Standard components -#endif -#endif // not APSTUDIO_INVOKED diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj deleted file mode 100644 index 01bf711..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj +++ /dev/null @@ -1,137 +0,0 @@ - - - - - Debug - Win32 - - - Release - Win32 - - - - $(VCTargetsPath11) - - - {E773817F-F3E5-4E78-ADD3-B70E11F611B6} - MfcTimeFliesLikeAnArrow - MFCProj - - - - Application - true - v110 - Unicode - Static - - - Application - false - v110 - true - Unicode - Static - - - - - - - - - - - - - true - $(VCInstallDir)include;..\src;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); - $(SolutionDir)\bin\$(Configuration)\ - obj\$(Configuration)\ - - - false - $(VCInstallDir)include;..\src;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath); - $(SolutionDir)\bin\$(Configuration)\ - obj\$(Configuration)\ - - - - Use - Level3 - Disabled - WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions) - - - Windows - true - - - false - true - _DEBUG;%(PreprocessorDefinitions) - - - 0x0409 - _DEBUG;%(PreprocessorDefinitions) - $(IntDir);%(AdditionalIncludeDirectories) - - - - - Level3 - Use - MaxSpeed - true - true - WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions) - - - Windows - true - true - true - - - false - true - NDEBUG;%(PreprocessorDefinitions) - - - 0x0409 - NDEBUG;%(PreprocessorDefinitions) - $(IntDir);%(AdditionalIncludeDirectories) - - - - - - - - - - - - - - - - - Create - Create - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters b/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters deleted file mode 100644 index 0b65204..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/MfcTimeFliesLikeAnArrow.vcxproj.filters +++ /dev/null @@ -1,63 +0,0 @@ - - - - - {4FC737F1-C7A5-4376-A066-2A32D752A2FF} - cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx - - - {93995380-89BD-4b04-88EB-625FBE52EBFB} - h;hpp;hxx;hm;inl;inc;xsd - - - {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} - rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - - - - - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - - - Source Files - - - Source Files - - - Source Files - - - - - Resource Files - - - - - Resource Files - - - - - Resource Files - - - \ No newline at end of file diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt b/Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt deleted file mode 100644 index 75971ad..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/ReadMe.txt +++ /dev/null @@ -1,95 +0,0 @@ -================================================================================ - MICROSOFT FOUNDATION CLASS LIBRARY : MfcTimeFliesLikeAnArrow Project Overview -=============================================================================== - -The application wizard has created this MfcTimeFliesLikeAnArrow application for -you. This application not only demonstrates the basics of using the Microsoft -Foundation Classes but is also a starting point for writing your application. - -This file contains a summary of what you will find in each of the files that -make up your MfcTimeFliesLikeAnArrow application. - -MfcTimeFliesLikeAnArrow.vcxproj - This is the main project file for VC++ projects generated using an application wizard. - It contains information about the version of Visual C++ that generated the file, and - information about the platforms, configurations, and project features selected with the - application wizard. - -MfcTimeFliesLikeAnArrow.vcxproj.filters - This is the filters file for VC++ projects generated using an Application Wizard. - It contains information about the association between the files in your project - and the filters. This association is used in the IDE to show grouping of files with - similar extensions under a specific node (for e.g. ".cpp" files are associated with the - "Source Files" filter). - -MfcTimeFliesLikeAnArrow.h - This is the main header file for the application. It includes other - project specific headers (including Resource.h) and declares the - CMfcTimeFliesLikeAnArrowApp application class. - -MfcTimeFliesLikeAnArrow.cpp - This is the main application source file that contains the application - class CMfcTimeFliesLikeAnArrowApp. - -MfcTimeFliesLikeAnArrow.rc - This is a listing of all of the Microsoft Windows resources that the - program uses. It includes the icons, bitmaps, and cursors that are stored - in the RES subdirectory. This file can be directly edited in Microsoft - Visual C++. Your project resources are in 1033. - -res\MfcTimeFliesLikeAnArrow.ico - This is an icon file, which is used as the application's icon. This - icon is included by the main resource file MfcTimeFliesLikeAnArrow.rc. - -res\MfcTimeFliesLikeAnArrow.rc2 - This file contains resources that are not edited by Microsoft - Visual C++. You should place all resources not editable by - the resource editor in this file. - -///////////////////////////////////////////////////////////////////////////// - -For the main frame window: - The project includes a standard MFC interface. - -MainFrm.h, MainFrm.cpp - These files contain the frame class CMainFrame, which is derived from - CFrameWnd and controls all SDI frame features. - -///////////////////////////////////////////////////////////////////////////// - - - -///////////////////////////////////////////////////////////////////////////// - -Other standard files: - -StdAfx.h, StdAfx.cpp - These files are used to build a precompiled header (PCH) file - named MfcTimeFliesLikeAnArrow.pch and a precompiled types file named StdAfx.obj. - -Resource.h - This is the standard header file, which defines new resource IDs. - Microsoft Visual C++ reads and updates this file. - -MfcTimeFliesLikeAnArrow.manifest - Application manifest files are used by Windows XP to describe an applications - dependency on specific versions of Side-by-Side assemblies. The loader uses this - information to load the appropriate assembly from the assembly cache or private - from the application. The Application manifest maybe included for redistribution - as an external .manifest file that is installed in the same folder as the application - executable or it may be included in the executable in the form of a resource. -///////////////////////////////////////////////////////////////////////////// - -Other notes: - -The application wizard uses "TODO:" to indicate parts of the source code you -should add to or customize. - -If your application uses MFC in a shared DLL, you will need -to redistribute the MFC DLLs. If your application is in a language -other than the operating system's locale, you will also have to -redistribute the corresponding localized resources mfc110XXX.DLL. -For more information on both of these topics, please see the section on -redistributing Visual C++ applications in MSDN documentation. - -///////////////////////////////////////////////////////////////////////////// diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h deleted file mode 100644 index f5a491a..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/Resource.h +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -//{{NO_DEPENDENCIES}} -// Microsoft Visual C++ generated include file. -// Used by MfcTimeFliesLikeAnArrow.rc -// -#define IDD_ABOUTBOX 100 -#define IDR_MAINFRAME 128 -#define IDR_MfcTimeFliesLikTYPE 130 - -// Next default values for new objects -// -#ifdef APSTUDIO_INVOKED -#ifndef APSTUDIO_READONLY_SYMBOLS -#define _APS_NEXT_RESOURCE_VALUE 310 -#define _APS_NEXT_CONTROL_VALUE 1000 -#define _APS_NEXT_SYMED_VALUE 310 -#define _APS_NEXT_COMMAND_VALUE 32771 -#endif -#endif diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico b/Rx/CPP/MfcTimeFliesLikeAnArrow/res/MfcTimeFliesLikeAnArrow.ico deleted file mode 100644 index d56fbcdfdf6eac0f4727c34770c26689271d96af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 67777 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 M!Rcd=t3a*;0Hl#_rT_o{ diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp deleted file mode 100644 index 4f165ae..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.cpp +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -// stdafx.cpp : source file that includes just the standard includes -// MfcTimeFliesLikeAnArrow.pch will be the pre-compiled header -// stdafx.obj will contain the pre-compiled type information - -#include "stdafx.h" - - diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h deleted file mode 100644 index 32ab5ac..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/stdafx.h +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - - -// stdafx.h : include file for standard system include files, -// or project specific include files that are used frequently, -// but are changed infrequently - -#pragma once - -#ifndef VC_EXTRALEAN -#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers -#endif - -#include "targetver.h" - -#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit - -// turns off MFC's hiding of some common and often safely ignored warning messages -#define _AFX_ALL_WARNINGS - -#include // MFC core and standard components -#include // MFC extensions - - - - - -#ifndef _AFX_NO_OLE_SUPPORT -#include // MFC support for Internet Explorer 4 Common Controls -#endif -#ifndef _AFX_NO_AFXCMN_SUPPORT -#include // MFC support for Windows Common Controls -#endif // _AFX_NO_AFXCMN_SUPPORT - -#include // MFC support for ribbons and control bars - - - - - - - - - -#ifdef _UNICODE -#if defined _M_IX86 -#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") -#elif defined _M_X64 -#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") -#else -#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") -#endif -#endif - -// STL includes -#include -#include -#include -#include -#include -#include - -#include "cpprx/rx.hpp" - diff --git a/Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h b/Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h deleted file mode 100644 index b447c86..0000000 --- a/Rx/CPP/MfcTimeFliesLikeAnArrow/targetver.h +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once - -// Including SDKDDKVer.h defines the highest available Windows platform. - -// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and -// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. - -#include diff --git a/Rx/CPP/RxCpp.sln b/Rx/CPP/RxCpp.sln deleted file mode 100644 index 76d33c8..0000000 --- a/Rx/CPP/RxCpp.sln +++ /dev/null @@ -1,26 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 2012 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testbench", "testbench\testbench.vcxproj", "{6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}" -EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MfcTimeFliesLikeAnArrow", "MfcTimeFliesLikeAnArrow\MfcTimeFliesLikeAnArrow.vcxproj", "{E773817F-F3E5-4E78-ADD3-B70E11F611B6}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Win32 = Debug|Win32 - Release|Win32 = Release|Win32 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Debug|Win32.ActiveCfg = Debug|Win32 - {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Debug|Win32.Build.0 = Debug|Win32 - {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Release|Win32.ActiveCfg = Release|Win32 - {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB}.Release|Win32.Build.0 = Release|Win32 - {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Debug|Win32.ActiveCfg = Debug|Win32 - {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Debug|Win32.Build.0 = Debug|Win32 - {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Release|Win32.ActiveCfg = Release|Win32 - {E773817F-F3E5-4E78-ADD3-B70E11F611B6}.Release|Win32.Build.0 = Release|Win32 - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection -EndGlobal diff --git a/Rx/CPP/license.txt b/Rx/CPP/license.txt deleted file mode 100644 index 5b47fbd..0000000 --- a/Rx/CPP/license.txt +++ /dev/null @@ -1,15 +0,0 @@ -Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. -Microsoft Open Technologies would like to thank its contributors, a list -of whom are at http://rx.codeplex.com/wikipage?title=Contributors. - -Licensed under the Apache License, Version 2.0 (the "License"); you -may not use this file except in compliance with the License. You may -obtain a copy of the License at - -http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -implied. See the License for the specific language governing permissions -and limitations under the License. \ No newline at end of file diff --git a/Rx/CPP/src/RxCpp.vcxproj b/Rx/CPP/src/RxCpp.vcxproj deleted file mode 100644 index 7a7398f..0000000 --- a/Rx/CPP/src/RxCpp.vcxproj +++ /dev/null @@ -1,61 +0,0 @@ - - - - - Debug - Win32 - - - Release - Win32 - - - - {A912FB36-33A7-4DDA-A7D6-D17F9495A623} - MakeFileProj - - - - Makefile - true - v110 - - - Makefile - false - v110 - - - - - - - - - - - - - WIN32;_DEBUG;$(NMakePreprocessorDefinitions) - - - WIN32;NDEBUG;$(NMakePreprocessorDefinitions) - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/Rx/CPP/src/RxCpp.vcxproj.filters b/Rx/CPP/src/RxCpp.vcxproj.filters deleted file mode 100644 index 2ce3d34..0000000 --- a/Rx/CPP/src/RxCpp.vcxproj.filters +++ /dev/null @@ -1,43 +0,0 @@ - - - - - {4FC737F1-C7A5-4376-A066-2A32D752A2FF} - cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx - - - {93995380-89BD-4b04-88EB-625FBE52EBFB} - h;hpp;hxx;hm;inl;inc;xsd - - - {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} - rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - - - - - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp b/Rx/CPP/src/cpprx/operators/CombineLatest.hpp deleted file mode 100644 index d847f9b..0000000 --- a/Rx/CPP/src/cpprx/operators/CombineLatest.hpp +++ /dev/null @@ -1,168 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_COMBINELATEST_HPP) -#define CPPRX_RX_OPERATORS_COMBINELATEST_HPP - -namespace rxcpp -{ - - namespace detail{ - template - struct CombineLatestSubscriber { - typedef typename SubscribeState::Latest Latest; - static void subscribe( - ComposableDisposable& cd, - const std::shared_ptr>& observer, - const std::shared_ptr& state, - const typename SubscribeState::Sources& sources) { - cd.Add(Subscribe( - std::get(sources), - // on next - [=](const typename std::tuple_element::type& element) - { - std::unique_lock guard(state->lock); - if (state->done) {return;} - std::get(state->latest) = element; - if (!std::get(state->latestValid)) { - std::get(state->latestValid) = true; - --state->pendingFirst; - } - if (state->pendingFirst == 0) { - auto args = state->latest; - typedef decltype(util::tuple_dispatch(state->selector, args)) U; - util::maybe result; - try { - result.set(util::tuple_dispatch(state->selector, args)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - }, - // on completed - [=] - { - std::unique_lock guard(state->lock); - if (state->done) {return;} - state->done = true; - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - std::unique_lock guard(state->lock); - if (state->done) {return;} - state->done = true; - observer->OnError(error); - cd.Dispose(); - })); - CombineLatestSubscriber:: - subscribe(cd, observer, state, sources); - } - }; - template - struct CombineLatestSubscriber { - static void subscribe( - ComposableDisposable& , - const std::shared_ptr>& , - const std::shared_ptr& , - const typename SubscribeState::Sources& ) {} - }; - } - -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto CombineLatest( - S selector, - const std::shared_ptr>&... source - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>...> Sources; - typedef std::tuple Latest; - typedef decltype(std::make_tuple((source, true)...)) LatestValid; - struct State { - typedef Latest Latest; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : latestValid() - , pendingFirst(SourcesSize::value) - , done(false) - , selector(std::move(selector)) - {} - std::mutex lock; - LatestValid latestValid; - size_t pendingFirst; - bool done; - S selector; - Latest latest; - }; - Sources sources(source...); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(selector)); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - cd.Add(Disposable([state](){state->done = true;})); - detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#else - template - auto CombineLatest( - S selector, - const std::shared_ptr>& source1, - const std::shared_ptr>& source2 - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>, std::shared_ptr>> Sources; - typedef std::tuple Latest; - typedef std::tuple LatestValid; - struct State { - typedef Latest Latest; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : latestValid() - , pendingFirst(SourcesSize::value) - , done(false) - , selector(std::move(selector)) - {} - std::mutex lock; - LatestValid latestValid; - size_t pendingFirst; - bool done; - S selector; - Latest latest; - }; - Sources sources(source1, source2); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - cd.Add(Disposable([state](){state->done = true;})); - detail::CombineLatestSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#endif - -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Concat.hpp b/Rx/CPP/src/cpprx/operators/Concat.hpp deleted file mode 100644 index e173732..0000000 --- a/Rx/CPP/src/cpprx/operators/Concat.hpp +++ /dev/null @@ -1,161 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_CONCAT_HPP) -#define CPPRX_RX_OPERATORS_CONCAT_HPP - -namespace rxcpp -{ - - template - ObservableT Concat( - const std::shared_ptr>& source) - { - typedef typename observable_item::type T; - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - bool completed; - bool subscribed; - bool cancel; - std::queue queue; - Scheduler::shared scheduler; - std::mutex lock; - }; - auto state = std::make_shared(); - state->cancel = false; - state->subscribed = 0; - state->scheduler = std::make_shared(); - - ComposableDisposable cd; - - SerialDisposable sd; - cd.Add(sd); - - cd.Add(Disposable([=]{ - std::unique_lock guard(state->lock); - state->cancel = true; }) - ); - - cd.Add(Subscribe( - source, - // on next - [=](const ObservableT& sourceElement) - { - bool cancel = false; - bool subscribed = false; - Scheduler::shared sched; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - sched = state->scheduler; - if (!cancel) { - subscribed = state->subscribed; - state->queue.push(sourceElement); - state->subscribed = true; - sched = state->scheduler; - } - } - if (!cancel && !subscribed) { - sd.Set(sched->Schedule( - fix0([state, cd, sd, observer](Scheduler::shared s, std::function self) -> Disposable - { - bool cancel = false; - bool finished = false; - ObservableT next; - { - std::unique_lock guard(state->lock); - finished = state->queue.empty(); - cancel = state->cancel; - if (!cancel && !finished) {next = state->queue.front(); state->queue.pop();} - } - if (!cancel && !finished) { - sd.Set(Subscribe( - next, - // on next - [=](const T& t) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnNext(std::move(t)); - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - bool subscribe = false; - { - std::unique_lock guard(state->lock); - finished = state->queue.empty() && state->completed; - subscribe = !state->queue.empty(); - state->subscribed = subscribe; - cancel = state->cancel; - } - if (!cancel) { - if (subscribe) {sd.Set(s->Schedule(std::move(self)));} - else if (finished) {observer->OnCompleted(); cd.Dispose();} - } - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); - })); - } - return Disposable::Empty(); - }))); - } - }, - // on completed - [=] - { - bool cancel = false; - bool finished = false; - { - std::unique_lock guard(state->lock); - state->completed = true; - finished = state->queue.empty() && !state->subscribed; - cancel = state->cancel; - } - if (!cancel && finished) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - bool cancel = false; - { - std::unique_lock guard(state->lock); - cancel = state->cancel; - } - if (!cancel) { - observer->OnError(std::current_exception()); - } - cd.Dispose(); - })); - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/ConnectForever.hpp b/Rx/CPP/src/cpprx/operators/ConnectForever.hpp deleted file mode 100644 index 1c873ee..0000000 --- a/Rx/CPP/src/cpprx/operators/ConnectForever.hpp +++ /dev/null @@ -1,22 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_CONNECTFOREVER_HPP) -#define CPPRX_RX_OPERATORS_CONNECTFOREVER_HPP - -namespace rxcpp -{ - - template - const std::shared_ptr> ConnectForever( - const std::shared_ptr>& source - ) - { - source->Connect(); - return observable(source); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Delay.hpp b/Rx/CPP/src/cpprx/operators/Delay.hpp deleted file mode 100644 index fe55f70..0000000 --- a/Rx/CPP/src/cpprx/operators/Delay.hpp +++ /dev/null @@ -1,79 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_DELAY_HPP) -#define CPPRX_RX_OPERATORS_DELAY_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> Delay( - const std::shared_ptr>& source, - Scheduler::clock::duration due, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - *cancel = true; })); - - SerialDisposable sd; - auto wsd = cd.Add(sd); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - auto sched_disposable = scheduler->Schedule( - due, - [=] (Scheduler::shared) -> Disposable { - if (!*cancel) - observer->OnNext(element); - return Disposable::Empty(); - } - ); - auto ssd = wsd.lock(); - if (ssd) - { - *ssd.get() = std::move(sched_disposable); - } - }, - // on completed - [=] - { - auto sched_disposable = scheduler->Schedule( - due, - [=](Scheduler::shared) -> Disposable { - if (!*cancel) - observer->OnCompleted(); - return Disposable::Empty(); - } - ); - auto ssd = wsd.lock(); - if (ssd) - { - *ssd.get() = std::move(sched_disposable); - } - }, - // on error - [=](const std::exception_ptr& error) - { - if (!*cancel) - observer->OnError(error); - })); - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Dematerialize.hpp b/Rx/CPP/src/cpprx/operators/Dematerialize.hpp deleted file mode 100644 index 796a133..0000000 --- a/Rx/CPP/src/cpprx/operators/Dematerialize.hpp +++ /dev/null @@ -1,93 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_DEMATERIALIZE_HPP) -#define CPPRX_RX_OPERATORS_DEMATERIALIZE_HPP - -namespace rxcpp -{ - -namespace detail -{ - -template -class DematerializeObservable : public Producer, T> -{ - typedef DematerializeObservable This; - typedef std::shared_ptr Parent; - typedef std::shared_ptr>>> Source; - typedef std::shared_ptr> Destination; - -private: - - Source source; - - class _ : public Sink<_, T>, public Observer>> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, Destination observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - virtual void OnNext(const std::shared_ptr>& n) - { - n->Accept([this](const T& t){ - this->SinkBase::observer->OnNext(t); - }, [this](){ - this->SinkBase::observer->OnCompleted(); - this->SinkBase::Dispose(); - }, [this](const std::exception_ptr& e){ - this->SinkBase::observer->OnError(e); - this->SinkBase::Dispose(); - }); - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer ProducerBase; -public: - - DematerializeObservable(Source source) : - ProducerBase([this](Parent parent, Destination observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(std::move(source)) - { - } -}; - -} - -template -std::shared_ptr> Dematerialize( - const std::shared_ptr>>>& source -) -{ - return std::make_shared>( - std::move(source) - ); -} - -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp b/Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp deleted file mode 100644 index 1796ed9..0000000 --- a/Rx/CPP/src/cpprx/operators/DistinctUntilChanged.hpp +++ /dev/null @@ -1,55 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_DISTINCTUNTILCHANGED_HPP) -#define CPPRX_RX_OPERATORS_DISTINCTUNTILCHANGED_HPP - -namespace rxcpp -{ - - // removes duplicate-sequenced values. e.g. 1,2,2,3,1 ==> 1,2,3,1 - template - std::shared_ptr> DistinctUntilChanged( - const std::shared_ptr>& source) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - State() : last(), hasValue(false) {} - T last; bool hasValue; - }; - - auto state = std::make_shared(); - state->hasValue = false; - - return Subscribe( - source, - // on next - [=](const T& element) - { - if (!state->hasValue || !(state->last == element)) - { - observer->OnNext(element); - state->last = element; - state->hasValue = true; - } - }, - // on completed - [=] - { - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Empty.hpp b/Rx/CPP/src/cpprx/operators/Empty.hpp deleted file mode 100644 index 09466ca..0000000 --- a/Rx/CPP/src/cpprx/operators/Empty.hpp +++ /dev/null @@ -1,74 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_EMPTY_HPP) -#define CPPRX_RX_OPERATORS_EMPTY_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class EmptyObservable : public Producer, T> - { - typedef std::shared_ptr> Parent; - Scheduler::shared scheduler; - - class _ : public Sink<_, T> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - auto local = parent; - auto that = this->shared_from_this(); - return parent->scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - that->SinkBase::observer->OnCompleted(); - that->SinkBase::Dispose(); - return Disposable::Empty(); - }); - } - }; - - typedef Producer, T> ProducerBase; - public: - - EmptyObservable(Scheduler::shared scheduler) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - scheduler(scheduler) - { - if (!scheduler) - { - this->scheduler = std::make_shared(); - } - } - }; - } - template - std::shared_ptr> Empty( - Scheduler::shared scheduler = nullptr - ) - { - return std::make_shared>(std::move(scheduler)); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/ForEach.hpp b/Rx/CPP/src/cpprx/operators/ForEach.hpp deleted file mode 100644 index e2c815e..0000000 --- a/Rx/CPP/src/cpprx/operators/ForEach.hpp +++ /dev/null @@ -1,49 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_FOREACH_HPP) -#define CPPRX_RX_OPERATORS_FOREACH_HPP - -namespace rxcpp -{ - - template - void ForEach( - const std::shared_ptr>& source, - typename util::identity>::type onNext - ) - { - std::mutex lock; - std::condition_variable wake; - bool done = false; - std::exception_ptr error; - auto observer = CreateObserver(std::move(onNext), - //on completed - [&]{ - std::unique_lock guard(lock); - done = true; - wake.notify_one(); - }, - //on error - [&](const std::exception_ptr& e){ - std::unique_lock guard(lock); - done = true; - error = std::move(e); - wake.notify_one(); - }); - - source->Subscribe(observer); - - { - std::unique_lock guard(lock); - wake.wait(guard, [&]{return done;}); - } - - if (error != std::exception_ptr()) { - std::rethrow_exception(error);} - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/GroupBy.hpp b/Rx/CPP/src/cpprx/operators/GroupBy.hpp deleted file mode 100644 index e9e7923..0000000 --- a/Rx/CPP/src/cpprx/operators/GroupBy.hpp +++ /dev/null @@ -1,102 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_GROUPBY_HPP) -#define CPPRX_RX_OPERATORS_GRUOPBY_HPP - -namespace rxcpp -{ - - template - auto GroupBy( - const std::shared_ptr>& source, - KS keySelector, - VS valueSelector, - L less) - -> std::shared_ptr::type, - typename std::decay::type>>>> - { - typedef typename std::decay::type Key; - typedef typename std::decay::type Value; - - typedef std::shared_ptr> LocalGroupObservable; - - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - typedef std::map>, L> Groups; - - struct State - { - explicit State(L less) : groups(std::move(less)) {} - std::mutex lock; - Groups groups; - }; - auto state = std::make_shared(std::move(less)); - - return Subscribe( - source, - // on next - [=](const T& element) - { - util::maybe key; - try { - key.set(keySelector(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - - if (!!key) { - auto keySubject = CreateGroupedSubject(*key.get()); - - typename Groups::iterator groupIt; - bool newGroup = false; - - { - std::unique_lock guard(state->lock); - std::tie(groupIt, newGroup) = state->groups.insert( - std::make_pair(*key.get(), keySubject) - ); - } - - if (newGroup) - { - LocalGroupObservable nextGroup(std::move(keySubject)); - observer->OnNext(nextGroup); - } - - util::maybe result; - try { - result.set(valueSelector(element)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - groupIt->second->OnNext(std::move(*result.get())); - } - } - }, - // on completed - [=] - { - for(auto& group : state->groups) { - group.second->OnCompleted(); - } - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - for(auto& group : state->groups) { - group.second->OnError(error); - } - observer->OnError(error); - }); - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Interval.hpp b/Rx/CPP/src/cpprx/operators/Interval.hpp deleted file mode 100644 index cd5a3e9..0000000 --- a/Rx/CPP/src/cpprx/operators/Interval.hpp +++ /dev/null @@ -1,62 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_INTERVAL_HPP) -#define CPPRX_RX_OPERATORS_INTERVAL_HPP - -namespace rxcpp -{ - - inline std::shared_ptr> Interval( - Scheduler::clock::duration due, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State : public std::enable_shared_from_this { - State(Scheduler::clock::duration due, - Scheduler::clock::time_point last, - std::shared_ptr> observer) : due(due), last(last), cursor(0), observer(observer) { - cd.Add(sd);} - - Scheduler::clock::duration due; - Scheduler::clock::time_point last; - size_t cursor; - std::shared_ptr> observer; - ComposableDisposable cd; - SerialDisposable sd; - - void Tick(Scheduler::shared s){ - observer->OnNext(cursor); - last += due; - ++cursor; - auto keepAlive = this->shared_from_this(); - sd.Set(s->Schedule( - last, - [this, keepAlive] (Scheduler::shared s) -> Disposable { - Tick(s); - return Disposable::Empty(); - } - )); - } - }; - auto state = std::make_shared(due, scheduler->Now(), observer); - - state->last += state->due; - state->sd.Set(scheduler->Schedule( - state->last, - [=] (Scheduler::shared s) -> Disposable { - state->Tick(s); - return Disposable::Empty(); - } - )); - return state->cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Iterate.hpp b/Rx/CPP/src/cpprx/operators/Iterate.hpp deleted file mode 100644 index 8478de1..0000000 --- a/Rx/CPP/src/cpprx/operators/Iterate.hpp +++ /dev/null @@ -1,86 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_ITERATE_HPP) -#define CPPRX_RX_OPERATORS_ITERATE_HPP - -namespace rxcpp -{ - - using std::begin; - using std::end; - template - auto Iterate( - Range r, - Scheduler::shared scheduler = nullptr) - -> std::shared_ptr::type>> - { - typedef decltype(begin(r)) It; - typedef typename std::decay::type T; - - if (!scheduler) {scheduler = std::make_shared();} - auto range = std::make_shared(std::move(r)); - - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - explicit State(std::shared_ptr rangeArg) { - // finally tracked down issue caused by clang compiler bug. - // initializing in the init list only works sometimes. - // a breakpoint here would eventually show that - // cancel was true instead of false. - // initializing in the body instead works every time. - // or using new instead of std::make_shared to create - // State will cause the init list to work every time - this->cancel = false; - this->range = std::move(rangeArg); - this->r_cursor = begin(*this->range); - this->r_end = end(*this->range); - } - bool cancel; - std::shared_ptr range; - It r_cursor; - It r_end; - }; - auto state = std::make_shared(range); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - state->cancel = true; - })); - - SerialDisposable sd; - - cd.Add(sd); - - sd.Set(scheduler->Schedule( - fix0([=](Scheduler::shared s, std::function self) -> Disposable - { - if (state->cancel) - return Disposable::Empty(); - - if (state->r_cursor == state->r_end) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(*state->r_cursor); - ++state->r_cursor; - sd.Set(s->Schedule(std::move(self))); - return cd; - } - return Disposable::Empty(); - }))); - - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Materialize.hpp b/Rx/CPP/src/cpprx/operators/Materialize.hpp deleted file mode 100644 index ede4d6e..0000000 --- a/Rx/CPP/src/cpprx/operators/Materialize.hpp +++ /dev/null @@ -1,87 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_MATERIALIZE_HPP) -#define CPPRX_RX_OPERATORS_MATERIALIZE_HPP - -namespace rxcpp -{ - -namespace detail -{ - -template -class MaterializeObservable : public Producer, std::shared_ptr>> -{ - typedef MaterializeObservable This; - typedef std::shared_ptr Parent; - typedef std::shared_ptr> Source; - typedef std::shared_ptr>>> Destination; - -private: - - Source source; - - class _ : public Sink<_, std::shared_ptr>>, public Observer - { - Parent parent; - - public: - typedef Sink<_, std::shared_ptr>> SinkBase; - - _(Parent parent, Destination observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - virtual void OnNext(const T& t) - { - SinkBase::observer->OnNext(Notification::CreateOnNext(t)); - } - virtual void OnCompleted() - { - SinkBase::observer->OnNext(Notification::CreateOnCompleted()); - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnNext(Notification::CreateOnError(e)); - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - }; - - typedef Producer>> ProducerBase; -public: - - MaterializeObservable(Source source) : - ProducerBase([this](Parent parent, Destination observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(std::move(source)) - { - } -}; - -} - -template -std::shared_ptr>>> Materialize( - const std::shared_ptr>& source -) -{ - return std::make_shared>( - std::move(source) - ); -} - -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Merge.hpp b/Rx/CPP/src/cpprx/operators/Merge.hpp deleted file mode 100644 index 4a724ca..0000000 --- a/Rx/CPP/src/cpprx/operators/Merge.hpp +++ /dev/null @@ -1,121 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_MERGE_HPP) -#define CPPRX_RX_OPERATORS_MERGE_HPP - -namespace rxcpp -{ - - namespace detail{ - template - struct MergeSubscriber { - typedef typename SubscribeState::result_type Item; - typedef std::shared_ptr> ResultObserver; - static void subscribe( - ComposableDisposable& cd, - const std::shared_ptr>& observer, - const std::shared_ptr& state, - const typename SubscribeState::Sources& sources) { - cd.Add(Subscribe( - std::get(sources), - // on next - [=](const Item& element) - { - observer->OnNext(element); - }, - // on completed - [=] - { - if (--state->pendingComplete == 0) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - MergeSubscriber:: - subscribe(cd, observer, state, sources); - } - }; - template - struct MergeSubscriber { - static void subscribe( - ComposableDisposable& , - const std::shared_ptr>& , - const std::shared_ptr& , - const typename SubscribeState::Sources& ) {} - }; - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - std::shared_ptr> Merge( - const std::shared_ptr>& firstSource, - const std::shared_ptr>&... otherSource - ) - { - typedef MergeSource result_type; - typedef decltype(std::make_tuple(firstSource, otherSource...)) Sources; - struct State - : std::enable_shared_from_this - { - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - State() - : pendingComplete(SourcesSize::value) - {} - std::atomic pendingComplete; - }; - Sources sources(firstSource, otherSource...); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - // bug on osx prevents using make_shared - std::shared_ptr state(new State()); - ComposableDisposable cd; - detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#else - template - std::shared_ptr> Merge( - const std::shared_ptr>& firstSource, - const std::shared_ptr>& otherSource - ) - { - typedef MergeSource result_type; - typedef decltype(std::make_tuple(firstSource, otherSource)) Sources; - struct State - : std::enable_shared_from_this - { - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - State() - : pendingComplete(SourcesSize::value) - {} - std::atomic pendingComplete; - }; - Sources sources(firstSource, otherSource); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - // bug on osx prevents using make_shared - std::shared_ptr state(new State()); - ComposableDisposable cd; - detail::MergeSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Multicast.hpp b/Rx/CPP/src/cpprx/operators/Multicast.hpp deleted file mode 100644 index e3d9c75..0000000 --- a/Rx/CPP/src/cpprx/operators/Multicast.hpp +++ /dev/null @@ -1,20 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_MULTICAST_HPP) -#define CPPRX_RX_OPERATORS_MULTICAST_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> Multicast(const std::shared_ptr < Observable < T >> &source, const std::shared_ptr& multicastSubject) - { - return std::static_pointer_cast>( - std::make_shared < ConnectableSubject < std::shared_ptr < Observable < T >> , std::shared_ptr >> (source, multicastSubject)); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Never.hpp b/Rx/CPP/src/cpprx/operators/Never.hpp deleted file mode 100644 index ffdd831..0000000 --- a/Rx/CPP/src/cpprx/operators/Never.hpp +++ /dev/null @@ -1,22 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_NEVER_HPP) -#define CPPRX_RX_OPERATORS_NEVER_HPP - -namespace rxcpp -{ - template - std::shared_ptr> Never() - { - return CreateObservable( - [=](std::shared_ptr>) -> Disposable - { - return Disposable::Empty(); - }); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp b/Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp deleted file mode 100644 index 4ff79f7..0000000 --- a/Rx/CPP/src/cpprx/operators/ObserveOnObserver.hpp +++ /dev/null @@ -1,53 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_OBSERVEONOBSERVER_HPP) -#define CPPRX_RX_OPERATORS_OBSERVEONOBSERVER_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> ObserveOnObserver( - const std::shared_ptr>& source, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observerArg) - -> Disposable - { - std::shared_ptr> observer( - new ScheduledObserver(scheduler, std::move(observerArg))); - - ComposableDisposable cd; - - cd.Add(*observer.get()); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - observer->OnNext(std::move(element)); - observer->EnsureActive(); - }, - // on completed - [=] - { - observer->OnCompleted(); - observer->EnsureActive(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(std::move(error)); - observer->EnsureActive(); - })); - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Publish.hpp b/Rx/CPP/src/cpprx/operators/Publish.hpp deleted file mode 100644 index fe2fb15..0000000 --- a/Rx/CPP/src/cpprx/operators/Publish.hpp +++ /dev/null @@ -1,34 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_PUBLISH_HPP) -#define CPPRX_RX_OPERATORS_PUBLISH_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source) - { - auto multicastSubject = std::make_shared>(); - return Multicast(source, multicastSubject); - } - - template - std::shared_ptr> Publish(const std::shared_ptr < Observable < T >> &source, V value) - { - auto multicastSubject = std::make_shared>(value); - return Multicast(source, multicastSubject); - } - - template - std::shared_ptr> PublishLast(const std::shared_ptr < Observable < T >> &source) - { - auto multicastSubject = std::make_shared>(); - return Multicast(source, multicastSubject); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Random.hpp b/Rx/CPP/src/cpprx/operators/Random.hpp deleted file mode 100644 index 741acb8..0000000 --- a/Rx/CPP/src/cpprx/operators/Random.hpp +++ /dev/null @@ -1,70 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_RANDOM_HPP) -#define CPPRX_RX_OPERATORS_RANDOM_HPP - -namespace rxcpp -{ - - // - // std::mt19937 twister; - // std::uniform_int_distribution xDistribution(0, xExtent - 1); - // auto xSource = Random(twister, xDistribution, [](std::mt19937& e){ - // e.seed(std::random_device()()); - // }); - // - template - std::shared_ptr> Random( - Engine e, - Distribution d, - Seeder s, - Scheduler::shared scheduler = nullptr) - { - typedef typename Distribution::result_type T; - if (!scheduler) {scheduler = std::make_shared();} - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Engine e; - Distribution d; - T step() - { - return d(e); - } - }; - auto state = std::make_shared(); - state->cancel = false; - state->e = e; - state->d = d; - - // allow the seed to be set - s(state->e); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - state->cancel = true; - })); - - cd.Add(scheduler->Schedule( - fix0([=](Scheduler::shared s, std::function self) -> Disposable - { - if (state->cancel) - return Disposable::Empty(); - - observer->OnNext(state->step()); - return s->Schedule(std::move(self)); - }))); - - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Range.hpp b/Rx/CPP/src/cpprx/operators/Range.hpp deleted file mode 100644 index 2e346cc..0000000 --- a/Rx/CPP/src/cpprx/operators/Range.hpp +++ /dev/null @@ -1,65 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_RANGE_HPP) -#define CPPRX_RX_OPERATORS_RANGE_HPP - -namespace rxcpp -{ - - - template - auto Range( - Integral start, Integral end = std::numeric_limits::max(), Integral step = 1, - Scheduler::shared scheduler = nullptr) - -> std::shared_ptr> - { - if (!scheduler) {scheduler = std::make_shared();} - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - struct State - { - bool cancel; - Integral i; - Integral rem; - }; - auto state = std::make_shared(); - state->cancel = false; - state->i = start; - state->rem = ((end - start) + step) / step; - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - state->cancel = true; - })); - - cd.Add(scheduler->Schedule( - fix0([=](Scheduler::shared s, std::function self) -> Disposable - { - if (state->cancel) - return Disposable::Empty(); - - if (!state->rem) - { - observer->OnCompleted(); - } - else - { - observer->OnNext(state->i); - --state->rem; - state->i += step; - return s->Schedule(std::move(self)); - } - return Disposable::Empty(); - }))); - - return cd; - }); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/RefCount.hpp b/Rx/CPP/src/cpprx/operators/RefCount.hpp deleted file mode 100644 index 9638ca1..0000000 --- a/Rx/CPP/src/cpprx/operators/RefCount.hpp +++ /dev/null @@ -1,102 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_REFCOUNT_HPP) -#define CPPRX_RX_OPERATORS_REFCOUNT_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class RefCountObservable : public Producer, T> - { - std::shared_ptr> source; - std::mutex lock; - size_t refcount; - util::maybe subscription; - - class _ : public Sink<_, T>, public Observer - { - std::shared_ptr> parent; - - public: - typedef Sink<_, T> SinkBase; - - _(std::shared_ptr> parent, std::shared_ptr> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - SerialDisposable subscription; - subscription.Set(parent->source->Subscribe(this->shared_from_this())); - - std::unique_lock guard(parent->lock); - if (++parent->refcount == 1) - { - parent->subscription.set(parent->source->Connect()); - } - - auto local = parent; - - return Disposable([subscription, local]() - { - subscription.Dispose(); - std::unique_lock guard(local->lock); - if (--local->refcount == 0) - { - local->subscription->Dispose(); - local->subscription.reset(); - } - }); - } - - virtual void OnNext(const T& t) - { - SinkBase::observer->OnNext(t); - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer, T> ProducerBase; - public: - - RefCountObservable(std::shared_ptr> source) : - ProducerBase([](std::shared_ptr> that, std::shared_ptr> observer, Disposable&& cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new RefCountObservable::_(that, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - source(std::move(source)), - refcount(0) - { - subscription.set(Disposable::Empty()); - } - }; - } - template - const std::shared_ptr> RefCount( - const std::shared_ptr>& source - ) - { - return std::make_shared>(source); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/Return.hpp b/Rx/CPP/src/cpprx/operators/Return.hpp deleted file mode 100644 index da3b49b..0000000 --- a/Rx/CPP/src/cpprx/operators/Return.hpp +++ /dev/null @@ -1,78 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_RETURN_HPP) -#define CPPRX_RX_OPERATORS_RETURN_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class ReturnObservable : public Producer, T> - { - typedef std::shared_ptr> Parent; - T value; - Scheduler::shared scheduler; - - class _ : public Sink<_, T> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - auto local = parent; - auto that = this->shared_from_this(); - return parent->scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - that->SinkBase::observer->OnNext(local->value); - that->SinkBase::observer->OnCompleted(); - that->SinkBase::Dispose(); - return Disposable::Empty(); - }); - } - }; - - typedef Producer, T> ProducerBase; - public: - - ReturnObservable(T value, Scheduler::shared scheduler) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new ReturnObservable::_(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - value(value), - scheduler(scheduler) - { - if (!scheduler) - { - this->scheduler = std::make_shared(); - } - } - }; - } - template - std::shared_ptr> Return( - T value, - Scheduler::shared scheduler = nullptr - ) - { - return std::make_shared>(std::move(value), std::move(scheduler)); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Scan.hpp b/Rx/CPP/src/cpprx/operators/Scan.hpp deleted file mode 100644 index fa3b00c..0000000 --- a/Rx/CPP/src/cpprx/operators/Scan.hpp +++ /dev/null @@ -1,127 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_SCAN_HPP) -#define CPPRX_RX_OPERATORS_SCAN_HPP - -namespace rxcpp -{ - namespace detail - { - template - class ScanObservable : public Producer, A> - { - typedef ScanObservable This; - typedef std::shared_ptr Parent; - typedef std::shared_ptr> Source; - typedef std::shared_ptr> Destination; - - public: - typedef std::function Accumulator; - typedef std::function(T)> Seeder; - - private: - - Source source; - util::maybe seed; - Accumulator accumulator; - Seeder seeder; - - class _ : public Sink<_, A>, public Observer - { - Parent parent; - util::maybe accumulation; - - public: - typedef Sink<_, A> SinkBase; - - _(Parent parent, Destination observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - virtual void OnNext(const T& t) - { - try - { - if (accumulation) - { - accumulation.set(parent->accumulator(*accumulation.get(), t)); - } - else - { - accumulation.set(!!parent->seed ? parent->accumulator(*parent->seed.get(), t) : *parent->seeder(t).get()); - } - } - catch (...) - { - SinkBase::observer->OnError(std::current_exception()); - SinkBase::Dispose(); - return; - } - SinkBase::observer->OnNext(*accumulation.get()); - } - virtual void OnCompleted() - { - if (!accumulation && !!parent->seed) { - SinkBase::observer->OnNext(*parent->seed.get()); - } - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer ProducerBase; - public: - - ScanObservable(Source source, util::maybe seed, Accumulator accumulator, Seeder seeder) : - ProducerBase([this](Parent parent, std::shared_ptr < Observer < A >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new ScanObservable::_(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(std::move(source)), - seed(std::move(seed)), - accumulator(std::move(accumulator)), - seeder(std::move(seeder)) - { - } - }; - } - template - std::shared_ptr> Scan( - const std::shared_ptr>& source, - A seed, - typename detail::ScanObservable::Accumulator accumulator - ) - { - return std::make_shared>( - std::move(source), - util::maybe(std::move(seed)), - std::move(accumulator), - [](T) -> util::maybe {abort(); return util::maybe();}); - } - template - std::shared_ptr> Scan( - const std::shared_ptr>& source, - typename detail::ScanObservable::Accumulator accumulator - ) - { - return std::make_shared>( - std::move(source), - util::maybe(), - std::move(accumulator), - [](T t) -> util::maybe {return util::maybe(t);}); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Select.hpp b/Rx/CPP/src/cpprx/operators/Select.hpp deleted file mode 100644 index 608d911..0000000 --- a/Rx/CPP/src/cpprx/operators/Select.hpp +++ /dev/null @@ -1,89 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_SELECT_HPP) -#define CPPRX_RX_OPERATORS_SELECT_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class SelectObservable : public Producer, Tout> - { - typedef SelectObservable Self; - typedef std::shared_ptr Parent; - typedef std::function Selector; - - std::shared_ptr> source; - Selector selector; - - class _ : public Sink<_, Tout>, public Observer - { - Parent parent; - - public: - typedef Sink<_, Tout> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < Tout >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - virtual void OnNext(const Tin& t) - { - util::maybe result; - try { - result.set(parent->selector(t)); - } catch (...) { - SinkBase::observer->OnError(std::current_exception()); - SinkBase::Dispose(); - } - if (!!result) { - SinkBase::observer->OnNext(*result.get()); - } - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer ProducerBase; - public: - - SelectObservable(const std::shared_ptr>& source, Selector selector) : - ProducerBase([this](Parent parent, std::shared_ptr < Observer < Tout >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new Self::_(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(source), - selector(std::move(selector)) - { - } - }; - } - template - auto Select( - const std::shared_ptr>& source, - S selector - ) -> const std::shared_ptr::type>> - { - typedef typename std::result_of::type Tout; - return std::make_shared>(source, std::move(selector)); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/SelectMany.hpp b/Rx/CPP/src/cpprx/operators/SelectMany.hpp deleted file mode 100644 index e282ced..0000000 --- a/Rx/CPP/src/cpprx/operators/SelectMany.hpp +++ /dev/null @@ -1,118 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_SELECTMANY_HPP) -#define CPPRX_RX_OPERATORS_SELECTMANY_HPP - -namespace rxcpp -{ - - template - auto SelectMany( - const std::shared_ptr>& source, - CS collectionSelector, - RS resultSelector) - -> const std::shared_ptr::type>::type&)>::type>> - { - typedef typename std::decay::type>::type C; - typedef typename observable_item::type CI; - typedef typename std::result_of::type U; - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - std::atomic count; - std::mutex lock; - ComposableDisposable group; - }; - auto state = std::make_shared(); - state->count = 0; - - SerialDisposable sourceDisposable; - state->group.Add(sourceDisposable); - - ++state->count; - sourceDisposable.Set(Subscribe( - source, - // on next - [=](const T& sourceElement) - { - util::maybe collection; - try { - collection.set(collectionSelector(sourceElement)); - } catch(...) { - std::unique_lock guard(state->lock); - observer->OnError(std::current_exception()); - state->group.Dispose(); - return; - } - - SerialDisposable inner; - state->group.Add(inner); - - ++state->count; - inner.Set(Subscribe( - *collection.get(), - // on next - [=](const CI& collectionElement) - { - util::maybe result; - try { - result.set(resultSelector(sourceElement, collectionElement)); - } catch(...) { - std::unique_lock guard(state->lock); - observer->OnError(std::current_exception()); - state->group.Dispose(); - } - std::unique_lock guard(state->lock); - observer->OnNext(std::move(*result.get())); - }, - // on completed - [=] - { - inner.Dispose(); - if (0 == --state->count) { - std::unique_lock guard(state->lock); - observer->OnCompleted(); - state->group.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - std::unique_lock guard(state->lock); - observer->OnError(error); - state->group.Dispose(); - })); - }, - // on completed - [=] - { - if (0 == --state->count) { - std::unique_lock guard(state->lock); - observer->OnCompleted(); - state->group.Dispose(); - } else { - sourceDisposable.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - std::unique_lock guard(state->lock); - observer->OnError(error); - state->group.Dispose(); - })); - return state->group; - }); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/Skip.hpp b/Rx/CPP/src/cpprx/operators/Skip.hpp deleted file mode 100644 index e635b71..0000000 --- a/Rx/CPP/src/cpprx/operators/Skip.hpp +++ /dev/null @@ -1,132 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_SKIP_HPP) -#define CPPRX_RX_OPERATORS_SKIP_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> Skip( - const std::shared_ptr>& source, - Integral n - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - enum type { - Skipping, - Forwarding - }; - }; - // keep count of remaining OnNext calls to skip and state. - auto remaining = std::make_shared, std::atomic>>(n, State::Skipping); - - ComposableDisposable cd; - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - if (std::get<1>(*remaining) == State::Forwarding) { - observer->OnNext(element); - } else { - auto local = --std::get<0>(*remaining); - - if (local == 0) { - std::get<1>(*remaining) = State::Forwarding; - } - } - }, - // on completed - [=] - { - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } - - template - std::shared_ptr> SkipUntil( - const std::shared_ptr>& source, - const std::shared_ptr>& terminus - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct SkipState { - enum type { - Skipping, - Taking - }; - }; - struct State { - State() : skipState(SkipState::Skipping) {} - std::atomic skipState; - }; - auto state = std::make_shared(); - - ComposableDisposable cd; - - cd.Add(Subscribe( - terminus, - // on next - [=](const U& element) - { - state->skipState = SkipState::Taking; - }, - // on completed - [=] - { - state->skipState = SkipState::Taking; - }, - // on error - [=](const std::exception_ptr& error) - { - state->skipState = SkipState::Taking; - })); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - if (state->skipState == SkipState::Taking) { - observer->OnNext(element); - } - }, - // on completed - [=] - { - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Subscribe.hpp b/Rx/CPP/src/cpprx/operators/Subscribe.hpp deleted file mode 100644 index 5717720..0000000 --- a/Rx/CPP/src/cpprx/operators/Subscribe.hpp +++ /dev/null @@ -1,27 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_SUBSCRIBE_HPP) -#define CPPRX_RX_OPERATORS_SUBSCRIBE_HPP - -namespace rxcpp -{ - - template - Disposable Subscribe( - const S& source, - typename util::identity::type&)>>::type onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) - { - auto observer = CreateObserver::type>( - std::move(onNext), std::move(onCompleted), std::move(onError)); - - return source->Subscribe(observer); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp b/Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp deleted file mode 100644 index 29a4c6b..0000000 --- a/Rx/CPP/src/cpprx/operators/SubscribeOnObservable.hpp +++ /dev/null @@ -1,35 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_SUBSCRIBEONOBSERVABLE_HPP) -#define CPPRX_RX_OPERATORS_SUBSCRIBEONOBSERVABLE_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> SubscribeOnObservable( - const std::shared_ptr>& source, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - ComposableDisposable cd; - - SerialDisposable sd; - cd.Add(sd); - - cd.Add(scheduler->Schedule([=](Scheduler::shared) -> Disposable { - sd.Set(ScheduledDisposable(scheduler, source->Subscribe(observer))); - return Disposable::Empty(); - })); - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Take.hpp b/Rx/CPP/src/cpprx/operators/Take.hpp deleted file mode 100644 index 20187d4..0000000 --- a/Rx/CPP/src/cpprx/operators/Take.hpp +++ /dev/null @@ -1,173 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_TAKE_HPP) -#define CPPRX_RX_OPERATORS_TAKE_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class TakeObservable : public Producer, T> - { - typedef std::shared_ptr> Parent; - - std::shared_ptr> source; - Integral count; - - class _ : public Sink<_, T>, public Observer - { - Parent parent; - Integral remaining; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent), - remaining(parent->count) - { - } - - virtual void OnNext(const T& t) - { - if (remaining > 0) - { - --remaining; - SinkBase::observer->OnNext(t); - - if (remaining == 0) - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - } - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer, T> ProducerBase; - public: - - TakeObservable(const std::shared_ptr>& source, Integral count) : - ProducerBase([this](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr<_>(new _(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(source), - count(count) - { - } - }; - } - template - std::shared_ptr> Take( - const std::shared_ptr>& source, - Integral n - ) - { - return std::make_shared>(source, n); - } - - - template - std::shared_ptr> TakeUntil( - const std::shared_ptr>& source, - const std::shared_ptr>& terminus - ) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - - struct TerminusState { - enum type { - Live, - Terminated - }; - }; - struct TakeState { - enum type { - Taking, - Completed - }; - }; - struct State { - State() : terminusState(TerminusState::Live), takeState(TakeState::Taking) {} - std::atomic terminusState; - std::atomic takeState; - }; - auto state = std::make_shared(); - - ComposableDisposable cd; - - cd.Add(Subscribe( - terminus, - // on next - [=](const U& ) - { - state->terminusState = TerminusState::Terminated; - }, - // on completed - [=] - { - state->terminusState = TerminusState::Terminated; - }, - // on error - [=](const std::exception_ptr& ) - { - state->terminusState = TerminusState::Terminated; - })); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - if (state->terminusState == TerminusState::Live) { - observer->OnNext(element); - } else if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on completed - [=] - { - if (state->takeState.exchange(TakeState::Completed) == TakeState::Taking) { - state->terminusState = TerminusState::Terminated; - observer->OnCompleted(); - cd.Dispose(); - } - }, - // on error - [=](const std::exception_ptr& error) - { - state->takeState = TakeState::Completed; - state->terminusState = TerminusState::Terminated; - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/Throttle.hpp b/Rx/CPP/src/cpprx/operators/Throttle.hpp deleted file mode 100644 index 89abdd1..0000000 --- a/Rx/CPP/src/cpprx/operators/Throttle.hpp +++ /dev/null @@ -1,97 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_THROTTLE_HPP) -#define CPPRX_RX_OPERATORS_THROTTLE_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> Throttle( - const std::shared_ptr>& source, - Scheduler::clock::duration due, - Scheduler::shared scheduler) - { - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - struct State { - State() : hasValue(false), id(0) {} - std::mutex lock; - T value; - bool hasValue; - size_t id; - }; - auto state = std::make_shared(); - - ComposableDisposable cd; - - SerialDisposable sd; - cd.Add(sd); - - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - size_t current = 0; - { - std::unique_lock guard(state->lock); - state->hasValue = true; - state->value = std::move(element); - current = ++state->id; - } - sd.Set(scheduler->Schedule( - due, - [=] (Scheduler::shared) -> Disposable { - { - std::unique_lock guard(state->lock); - if (state->hasValue && state->id == current) { - observer->OnNext(std::move(state->value)); - } - state->hasValue = false; - } - - return Disposable::Empty(); - } - )); - }, - // on completed - [=] - { - bool sendValue = false; - T value; - { - std::unique_lock guard(state->lock); - sendValue = state->hasValue; - if (sendValue) { - value = std::move(state->value);} - state->hasValue = false; - ++state->id; - } - if (sendValue) { - observer->OnNext(std::move(value));} - observer->OnCompleted(); - cd.Dispose(); - }, - // on error - [=](const std::exception_ptr& error) - { - { - std::unique_lock guard(state->lock); - state->hasValue = false; - ++state->id; - } - observer->OnError(error); - cd.Dispose(); - })); - return cd; - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Throw.hpp b/Rx/CPP/src/cpprx/operators/Throw.hpp deleted file mode 100644 index 425f5eb..0000000 --- a/Rx/CPP/src/cpprx/operators/Throw.hpp +++ /dev/null @@ -1,104 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_THROW_HPP) -#define CPPRX_RX_OPERATORS_THROW_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class ThrowObservable : public Producer, T> - { - typedef ThrowObservable This; - typedef std::shared_ptr Parent; - - std::exception_ptr exception; - Scheduler::shared scheduler; - - class _ : public Sink<_, T> - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - auto local = parent; - auto that = this->shared_from_this(); - return parent->scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - that->SinkBase::observer->OnError(local->exception); - that->SinkBase::Dispose(); - return Disposable::Empty(); - }); - } - }; - - typedef Producer ProducerBase; - public: - - ThrowObservable(std::exception_ptr exception, Scheduler::shared scheduler) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new ThrowObservable::_(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - exception(exception), - scheduler(scheduler) - { - if (!scheduler) - { - this->scheduler = std::make_shared(); - } - } - }; - - struct throw_ptr_tag{}; - struct throw_instance_tag{}; - - template - std::shared_ptr> make_throw( - throw_ptr_tag&&, - std::exception_ptr exception, - Scheduler::shared scheduler = nullptr - ) - { - return std::make_shared>(std::move(exception), std::move(scheduler)); - } - - template - std::shared_ptr> make_throw( - throw_instance_tag&&, - E e, - Scheduler::shared scheduler = nullptr - ) - { - std::exception_ptr exception; - try {throw e;} catch(...) {exception = std::current_exception();} - return std::make_shared>(std::move(exception), std::move(scheduler)); - } - } - template - std::shared_ptr> Throw( - E e, - Scheduler::shared scheduler = nullptr - ) - { - return detail::make_throw(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::forward(e), std::move(scheduler)); - } -} - -#endif diff --git a/Rx/CPP/src/cpprx/operators/ToAsync.hpp b/Rx/CPP/src/cpprx/operators/ToAsync.hpp deleted file mode 100644 index 33bffcb..0000000 --- a/Rx/CPP/src/cpprx/operators/ToAsync.hpp +++ /dev/null @@ -1,48 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_TOASYNC_HPP) -#define CPPRX_RX_OPERATORS_TOASYNC_HPP - -namespace rxcpp -{ - -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto ToAsync(F f, Scheduler::shared scheduler = nullptr) - ->std::function < std::shared_ptr < Observable< decltype(f((*(A*)nullptr)...)) >> (const A&...)> - { - typedef decltype(f((*(A*) nullptr)...)) R; - if (!scheduler) - { - scheduler = std::make_shared(); - } - return [=](const A&... a) -> std::shared_ptr < Observable> - { - auto args = std::make_tuple(a...); - auto result = CreateAsyncSubject(); - scheduler->Schedule([=](Scheduler::shared) -> Disposable - { - util::maybe value; - try - { - value.set(util::tuple_dispatch(f, args)); - } - catch (...) - { - result->OnError(std::current_exception()); - return Disposable::Empty(); - } - result->OnNext(*value.get()); - result->OnCompleted(); - return Disposable::Empty(); - }); - return result; - }; - } -#endif -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/ToStdCollection.hpp b/Rx/CPP/src/cpprx/operators/ToStdCollection.hpp deleted file mode 100644 index 25813b1..0000000 --- a/Rx/CPP/src/cpprx/operators/ToStdCollection.hpp +++ /dev/null @@ -1,44 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_TOSTDCOLLECTION_HPP) -#define CPPRX_RX_OPERATORS_TOSTDCOLLECTION_HPP - -namespace rxcpp -{ - - template - std::shared_ptr> ToStdCollection( - const std::shared_ptr>& source - ) - { - typedef typename StdCollection::value_type Value; - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - auto stdCollection = std::make_shared(); - return Subscribe( - source, - // on next - [=](const Value& element) - { - stdCollection->insert(stdCollection->end(), element); - }, - // on completed - [=] - { - observer->OnNext(std::move(*stdCollection.get())); - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - observer->OnError(error); - }); - }); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Using.hpp b/Rx/CPP/src/cpprx/operators/Using.hpp deleted file mode 100644 index d435d75..0000000 --- a/Rx/CPP/src/cpprx/operators/Using.hpp +++ /dev/null @@ -1,112 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_USING_HPP) -#define CPPRX_RX_OPERATORS_USING_HPP - -namespace rxcpp -{ - - namespace detail - { - template - class UsingObservable : public Producer, T> - { - typedef UsingObservable This; - typedef std::shared_ptr Parent; - typedef typename std::decay::type Source; - - public: - typedef std::function ResourceFactory; - typedef std::function ObservableFactory; - - private: - ResourceFactory resourceFactory; - ObservableFactory observableFactory; - - class _ : public Sink<_, T>, public Observer - { - Parent parent; - Source source; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - Disposable Run() - { - ComposableDisposable cd; - auto disposable = Disposable::Empty(); - - try - { - auto resource = parent->resourceFactory(); - disposable = resource; - source = parent->observableFactory(resource); - } - catch (...) - { - cd.Add(Throw(std::current_exception())->Subscribe(this->shared_from_this())); - cd.Add(std::move(disposable)); - return cd; - } - - cd.Add(source->Subscribe(this->shared_from_this())); - cd.Add(std::move(disposable)); - return cd; - } - - virtual void OnNext(const T& t) - { - SinkBase::observer->OnNext(t); - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer ProducerBase; - public: - - UsingObservable(ResourceFactory resourceFactory, ObservableFactory observableFactory) : - ProducerBase([](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new UsingObservable::_(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return sink->Run(); - }), - resourceFactory(resourceFactory), - observableFactory(observableFactory) - { - } - }; - } - template - auto Using( - RF resourceFactory, - OF observableFactory - ) - -> decltype(observableFactory(resourceFactory())) - { - typedef decltype(observableFactory(resourceFactory())) ScopedObservable; - typedef typename observable_item::type T; - typedef decltype(resourceFactory()) R; - return std::make_shared>(std::move(resourceFactory), std::move(observableFactory)); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Where.hpp b/Rx/CPP/src/cpprx/operators/Where.hpp deleted file mode 100644 index d0089bd..0000000 --- a/Rx/CPP/src/cpprx/operators/Where.hpp +++ /dev/null @@ -1,86 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_WHERE_HPP) -#define CPPRX_RX_OPERATORS_WHERE_HPP - -namespace rxcpp -{ - namespace detail - { - template - class WhereObservable : public Producer, T> - { - typedef std::shared_ptr> Parent; - typedef std::function Predicate; - - std::shared_ptr> source; - Predicate predicate; - - class _ : public Sink<_, T>, public Observer - { - Parent parent; - - public: - typedef Sink<_, T> SinkBase; - - _(Parent parent, std::shared_ptr < Observer < T >> observer, Disposable cancel) : - SinkBase(std::move(observer), std::move(cancel)), - parent(parent) - { - } - - virtual void OnNext(const T& t) - { - util::maybe shouldRun; - try { - shouldRun.set(parent->predicate(t)); - } catch (...) { - SinkBase::observer->OnError(std::current_exception()); - SinkBase::Dispose(); - } - if (!!shouldRun && *shouldRun.get()) { - SinkBase::observer->OnNext(t); - } - } - virtual void OnCompleted() - { - SinkBase::observer->OnCompleted(); - SinkBase::Dispose(); - } - virtual void OnError(const std::exception_ptr& e) - { - SinkBase::observer->OnError(e); - SinkBase::Dispose(); - } - }; - - typedef Producer, T> ProducerBase; - public: - - WhereObservable(const std::shared_ptr>& source, Predicate predicate) : - ProducerBase([this](Parent parent, std::shared_ptr < Observer < T >> observer, Disposable && cancel, typename ProducerBase::SetSink setSink) -> Disposable - { - auto sink = std::shared_ptr(new WhereObservable::_(parent, observer, std::move(cancel))); - setSink(sink->GetDisposable()); - return this->source->Subscribe(sink); - }), - source(source), - predicate(std::move(predicate)) - { - } - }; - } - template - std::shared_ptr> Where( - const std::shared_ptr>& source, - P predicate - ) - { - return std::make_shared>(source, std::move(predicate)); - } -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/operators/Zip.hpp b/Rx/CPP/src/cpprx/operators/Zip.hpp deleted file mode 100644 index 8788bbc..0000000 --- a/Rx/CPP/src/cpprx/operators/Zip.hpp +++ /dev/null @@ -1,223 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "../rx-operators.hpp" - -#if !defined(CPPRX_RX_OPERATORS_ZIP_HPP) -#define CPPRX_RX_OPERATORS_ZIP_HPP - -namespace rxcpp -{ - - namespace detail{ - template - struct ZipSubscriber { - typedef typename std::tuple_element::type::second_type::value_type Item; - typedef std::shared_ptr> ResultObserver; - struct Next - { - std::shared_ptr state; - const ResultObserver& observer; - const ComposableDisposable& cd; - explicit Next( - std::shared_ptr state, - const ResultObserver& observer, - const ComposableDisposable& cd) - : state(std::move(state)) - , observer(observer) - , cd(cd) { - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - void operator()(ZipQueue&... queue) { - // build array of bool that we can iterate to detect empty queues - bool empties[] = {queue.second.empty()...}; - if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { - // all queues have an item. - // - // copy front of each queue - auto args = std::make_tuple(queue.second.front()...); - - // cause side-effect of pop on each queue - std::make_tuple((queue.second.pop(), true)...); - - typedef decltype(util::tuple_dispatch(state->selector, args)) U; - util::maybe result; - try { - result.set(util::tuple_dispatch(state->selector, args)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - // build new array to check for any empty queue - bool post_empties[] = {queue.first && queue.second.empty()...}; - if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { - // at least one queue is empty and at least one of the sources has completed. - // it is time to stop. - observer->OnCompleted(); - cd.Dispose(); - } - } -#else - template - void operator()(ZipQueue1& queue1, ZipQueue2& queue2) { - // build array of bool that we can iterate to detect empty queues - bool empties[] = {queue1.second.empty(), queue2.second.empty()}; - if (std::find(std::begin(empties), std::end(empties), true) == std::end(empties)) { - // all queues have an item. - // - // copy front of each queue - auto args = std::make_tuple(queue1.second.front(), queue2.second.front()); - - queue1.second.pop(); - queue2.second.pop(); - - typedef decltype(util::tuple_dispatch(state->selector, args)) U; - util::maybe result; - try { - result.set(util::tuple_dispatch(state->selector, args)); - } catch(...) { - observer->OnError(std::current_exception()); - } - if (!!result) { - observer->OnNext(std::move(*result.get())); - } - } - // build new array to check for any empty queue - bool post_empties[] = {queue1.first && queue1.second.empty(), queue2.first && queue2.second.empty()}; - if (std::find(std::begin(post_empties), std::end(post_empties), true) != std::end(post_empties)) { - // at least one queue is empty and at least one of the sources has completed. - // it is time to stop. - observer->OnCompleted(); - cd.Dispose(); - } - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES - }; - static void subscribe( - ComposableDisposable& cd, - const std::shared_ptr>& observer, - const std::shared_ptr& state, - const typename SubscribeState::Sources& sources) { - cd.Add(Subscribe( - std::get(sources), - // on next - [=](const Item& element) - { - std::unique_lock guard(state->lock); - if (state->isStopped) {return;} - std::get(state->queues).second.push(element); - Next next(state, observer, cd); - util::tuple_dispatch(next, state->queues); - }, - // on completed - [=] - { - std::unique_lock guard(state->lock); - if (state->isStopped) {return;} - std::get(state->queues).first = true; - Next next(state, observer, cd); - util::tuple_dispatch(next, state->queues); - }, - // on error - [=](const std::exception_ptr& error) - { - std::unique_lock guard(state->lock); - if (state->isStopped) {return;} - observer->OnError(error); - cd.Dispose(); - })); - ZipSubscriber:: - subscribe(cd, observer, state, sources); - } - }; - template - struct ZipSubscriber { - static void subscribe( - ComposableDisposable& , - const std::shared_ptr>& , - const std::shared_ptr& , - const typename SubscribeState::Sources& ) {} - }; - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto Zip( - S selector, - const std::shared_ptr>&... source - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>...> Sources; - typedef std::tuple>...> Queues; - struct State { - typedef Queues Queues; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : selector(std::move(selector)) - , isStopped(false) - {} - std::mutex lock; - S selector; - Queues queues; - bool isStopped; - }; - Sources sources(source...); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - cd.Add(Disposable([state](){state->isStopped = true;})); - detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#else - template - auto Zip( - S selector, - const std::shared_ptr>& source1, - const std::shared_ptr>& source2 - ) - -> std::shared_ptr::type>> - { - typedef typename std::result_of::type result_type; - typedef std::tuple>, std::shared_ptr>> Sources; - typedef std::tuple>, std::pair>> Queues; - struct State { - typedef Queues Queues; - typedef Sources Sources; - typedef result_type result_type; - typedef std::tuple_size SourcesSize; - explicit State(S selector) - : selector(std::move(selector)) - , isStopped(false) - {} - std::mutex lock; - S selector; - Queues queues; - bool isStopped; - }; - Sources sources(source1, source2); - // bug on osx prevents using make_shared - std::shared_ptr state(new State(std::move(selector))); - return CreateObservable( - [=](std::shared_ptr> observer) -> Disposable - { - ComposableDisposable cd; - detail::ZipSubscriber<0, State::SourcesSize::value, State>::subscribe(cd, observer, state, sources); - return cd; - }); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES -} - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-base.hpp b/Rx/CPP/src/cpprx/rx-base.hpp deleted file mode 100644 index 43acb56..0000000 --- a/Rx/CPP/src/cpprx/rx-base.hpp +++ /dev/null @@ -1,1029 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_BASE_HPP) -#define CPPRX_RX_BASE_HPP - -namespace rxcpp -{ - ////////////////////////////////////////////////////////////////////// - // - // Abstract interfaces - - template - struct Observer - { - virtual void OnNext(const T&) {} - virtual void OnCompleted() {} - virtual void OnError(const std::exception_ptr&) {} - - virtual ~Observer() {} - }; - - class Disposable - { - Disposable(); - Disposable(const Disposable&); - typedef std::function dispose_type; - dispose_type dispose; - public: - explicit Disposable(dispose_type disposearg) - : dispose(std::move(disposearg)) { - disposearg = nullptr;} - Disposable(Disposable&& other) - : dispose(std::move(other.dispose)) { - other.dispose = nullptr; } - Disposable& operator=(Disposable other) { - swap(other); - return *this; - } - void Dispose() - { - if (dispose) { - dispose(); - dispose = nullptr; - } - } - void swap(Disposable& rhs) {{using std::swap; swap(dispose, rhs.dispose);}} - static Disposable Empty() { return Disposable(nullptr); } - }; - inline void swap(Disposable& lhs, Disposable& rhs) {lhs.swap(rhs);} - - template - struct Observable - { - virtual Disposable Subscribe(std::shared_ptr> observer) = 0; - virtual ~Observable() {} - }; - - template - struct GroupedObservable : Observable - { - virtual K Key() = 0; - virtual ~GroupedObservable() {} - }; - - template - struct ConnectableObservable : Observable - { - virtual Disposable Connect() = 0; - virtual ~ConnectableObservable() {} - }; - - struct Scheduler : public std::enable_shared_from_this - { - typedef std::chrono::steady_clock clock; - typedef std::shared_ptr shared; - - class Work { - struct bool_r{}; - static bool_r bool_true(){return bool_r();} - typedef decltype(&bool_true) bool_type; - - struct State - { - typedef std::function F; - F work; - bool disposed; - inline void Dispose() { - disposed = true; - } - }; - std::shared_ptr state; - - template - struct assign - { - void operator()(std::shared_ptr& state, State::F fn) { - if (!state) { - state = std::make_shared(); - } - state->work = std::move(fn); - } - void operator()(std::shared_ptr& state, std::nullptr_t) { - if (state) { - state->work = nullptr; - } - } - }; - - template - struct assign - { - void operator()(std::shared_ptr& state, const Work& o) { - state = o.state; - } - void operator()(std::shared_ptr& state, Work&& o) { - state = std::move(o.state); - } - }; - public: - Work() - : state(std::make_shared()) - { - state->disposed = false; - } - template - Work(Fn&& fn) - : state(std::make_shared()) - { - assign<1, std::is_same::type>::value>()(state, std::forward(fn)); - state->disposed = false; - } - template - Work& operator=(Fn&& fn) - { - assign<1, std::is_same::type>::value>()(state, std::forward(fn)); - return *this; - } - inline Disposable operator()(shared s) { - if (!state->disposed) { - return state->work(s); - } - return Disposable::Empty(); - } - inline operator bool_type() const {return (!state->disposed && !!state->work) ? &bool_true : nullptr;} - inline void Dispose() const { - state->Dispose(); - } - inline operator Disposable() const - { - // make sure to capture state and not 'this'. - auto local = state; - return Disposable([local]{ - local->Dispose(); - }); - } - }; - - shared get() {return shared_from_this();} - - virtual ~Scheduler() {} - - virtual clock::time_point Now() =0; - virtual Disposable Schedule(Work work) = 0; - virtual Disposable Schedule(clock::duration due, Work work) = 0; - virtual Disposable Schedule(clock::time_point due, Work work) = 0; - }; - - ////////////////////////////////////////////////////////////////////// - // - // disposables - - - // reference handle type for a container for composing disposables - class ComposableDisposable - { - typedef std::shared_ptr shared_disposable; - typedef std::weak_ptr weak_disposable; - struct State - { - std::vector disposables; - std::mutex lock; - bool isDisposed; - - State() : isDisposed(false) - { - } - weak_disposable Add(Disposable&& d) - { - return Add(std::make_shared(std::move(d))); - } - weak_disposable Add(shared_disposable s) - { - std::unique_lock guard(lock); - if (isDisposed) { - guard.unlock(); - s->Dispose(); - } else { - auto end = std::end(disposables); - auto it = std::find(std::begin(disposables), end, s); - if (it == end) - { - disposables.emplace_back(s); - } - } - return s; - } - void Remove(weak_disposable w) - { - std::unique_lock guard(lock); - auto s = w.lock(); - if (s) - { - auto end = std::end(disposables); - auto it = std::find(std::begin(disposables), end, s); - if (it != end) - { - disposables.erase(it); - } - } - } - void Dispose() - { - std::unique_lock guard(lock); - - if (!isDisposed) - { - isDisposed = true; - auto v = std::move(disposables); - guard.unlock(); - - std::for_each(v.begin(), v.end(), - [](shared_disposable& d) { - d->Dispose(); }); - } - } - }; - - mutable std::shared_ptr state; - - public: - - ComposableDisposable() - : state(std::make_shared()) - { - } - weak_disposable Add(shared_disposable s) const - { - return state->Add(std::move(s)); - } - weak_disposable Add(Disposable d) const - { - return state->Add(std::move(d)); - } - void Remove(weak_disposable w) const - { - state->Remove(w); - } - void Dispose() const - { - state->Dispose(); - } - operator Disposable() const - { - // make sure to capture state and not 'this'. - // usage means that 'this' will usualy be destructed - // immediately - auto local = state; - return Disposable([local]{ - local->Dispose(); - }); - } - }; - - class ScheduledDisposable - { - struct State : public std::enable_shared_from_this - { - Scheduler::shared scheduler; - Disposable disposable; - - State(Scheduler::shared scheduler, Disposable disposable) - : scheduler(std::move(scheduler)) - , disposable(std::move(disposable)) - { - } - void Dispose() - { - auto local = std::move(scheduler); - if (local) { - auto keepAlive = shared_from_this(); - local->Schedule([keepAlive] (Scheduler::shared) -> Disposable { - keepAlive->disposable.Dispose(); - return Disposable::Empty(); - }); - } - } - }; - - std::shared_ptr state; - - ScheduledDisposable(); - public: - - ScheduledDisposable(Scheduler::shared scheduler, Disposable disposable) - : state(new State(std::move(scheduler), std::move(disposable))) - { - } - ScheduledDisposable(const ScheduledDisposable& o) - : state(o.state) - { - } - ScheduledDisposable(ScheduledDisposable&& o) - : state(std::move(o.state)) - { - o.state = nullptr; - } - ScheduledDisposable& operator=(ScheduledDisposable o) { - using std::swap; - swap(o.state, state); - return *this; - } - void Dispose() const - { - state->Dispose(); - } - operator Disposable() const - { - // make sure to capture state and not 'this'. - // usage means that 'this' will usualy be destructed - // immediately - auto local = state; - return Disposable([local]{ - local->Dispose(); - }); - } - }; - - class SerialDisposable - { - struct State - { - mutable Disposable disposable; - mutable bool disposed; - mutable std::mutex lock; - - State() : disposable(Disposable::Empty()), disposed(false) {} - - void Set(Disposable disposeArg) const - { - std::unique_lock guard(lock); - if (!disposed) { - using std::swap; - swap(disposable, disposeArg); - } - guard.unlock(); - disposeArg.Dispose(); - } - void Dispose() - { - std::unique_lock guard(lock); - if (!disposed) { - disposed = true; - auto local = std::move(disposable); - guard.unlock(); - local.Dispose(); - } - } - }; - - mutable std::shared_ptr state; - - public: - - SerialDisposable() - : state(std::make_shared()) - { - } - void Dispose() const - { - state->Dispose(); - } - void Set(Disposable disposeArg) const - { - state->Set(std::move(disposeArg)); - } - operator Disposable() const - { - // make sure to capture state and not 'this'. - // usage means that 'this' will usualy be destructed - // immediately - auto local = state; - return Disposable([local]{ - local->Dispose(); - }); - } - }; - - template - class ScheduledItem { - public: - ScheduledItem(Absolute due, Scheduler::Work work) - : due(due) - , work(std::move(work)) - {} - - static Disposable Do(Scheduler::Work& work, Scheduler::shared scheduler) - { - if (work) - { - return work(std::move(scheduler)); - } - return Disposable::Empty(); - } - - Absolute due; - Scheduler::Work work; - }; - - struct LocalScheduler : public Scheduler - { - private: - LocalScheduler(const LocalScheduler&); - - public: - typedef ScheduledItem QueueItem; - static Disposable Do(Work& work, const Scheduler::shared& scheduler) - { - return QueueItem::Do(work, scheduler); - } - - public: - LocalScheduler() - { - } - virtual ~LocalScheduler() - { - } - - virtual clock::time_point Now() {return clock::now();} - - using Scheduler::Schedule; - virtual Disposable Schedule(Work work) - { - clock::time_point dueTime = clock::now(); - return Schedule(dueTime, std::move(work)); - } - - virtual Disposable Schedule(clock::duration due, Work work) - { - clock::time_point dueTime = clock::now() + due; - return Schedule(dueTime, std::move(work)); - } - }; - - template - struct VirtualTimeSchedulerBase : public Scheduler - { - private: - VirtualTimeSchedulerBase(const VirtualTimeSchedulerBase&); - - bool is_enabled; - - public: - virtual ~VirtualTimeSchedulerBase() - { - } - - protected: - VirtualTimeSchedulerBase() - : is_enabled(false) - , clock_now(0) - { - } - explicit VirtualTimeSchedulerBase(Absolute initialClock) - : is_enabled(false) - , clock_now(initialClock) - { - } - - typedef Scheduler::clock clock; - typedef Scheduler::Work Work; - typedef ScheduledItem QueueItem; - - Absolute clock_now; - - virtual Absolute Add(Absolute, Relative) =0; - - virtual clock::time_point ToTimePoint(Absolute) =0; - virtual Relative ToRelative(clock::duration) =0; - - virtual util::maybe GetNext() =0; - - public: - static Disposable Do(Work& work, const Scheduler::shared& scheduler) - { - return QueueItem::Do(work, scheduler); - } - - virtual Disposable ScheduleAbsolute(Absolute, Work) =0; - - virtual Disposable ScheduleRelative(Relative dueTime, Work work) { - auto at = Add(clock_now, dueTime); - return ScheduleAbsolute(at, std::move(work)); - } - - virtual clock::time_point Now() {return ToTimePoint(clock_now);} - - bool IsEnabled() {return is_enabled;} - Absolute Clock() {return clock_now;} - - using Scheduler::Schedule; - virtual Disposable Schedule(Work work) - { - return ScheduleAbsolute(clock_now, std::move(work)); - } - - virtual Disposable Schedule(clock::duration due, Work work) - { - return ScheduleRelative(ToRelative(due), std::move(work)); - } - - virtual Disposable Schedule(clock::time_point due, Work work) - { - return ScheduleRelative(ToRelative(due - Now()), std::move(work)); - } - - void Start() - { - if (!is_enabled) { - is_enabled = true; - do { - auto next = GetNext(); - if (!!next && !!next->work) { - if (next->due > clock_now) { - clock_now = next->due; - } - Do(next->work, shared_from_this()); - } - else { - is_enabled = false; - } - } while (is_enabled); - } - } - - void Stop() - { - is_enabled = false; - } - - void AdvanceTo(Absolute time) - { - if (time < clock_now) { - abort(); - } - - if (time == clock_now) { - return; - } - - if (!is_enabled) { - is_enabled = true; - do { - auto next = GetNext(); - if (!!next && !!next->work && next->due <= time) { - if (next->due > clock_now) { - clock_now = next->due; - } - Do(next->work, shared_from_this()); - } - else { - is_enabled = false; - } - } while (is_enabled); - - clock_now = time; - } - else { - abort(); - } - } - - void AdvanceBy(Relative time) - { - auto dt = Add(clock_now, time); - - if (dt < clock_now) { - abort(); - } - - if (dt == clock_now) { - return; - } - - if (!is_enabled) { - AdvanceTo(dt); - } - else { - abort(); - } - } - - void Sleep(Relative time) - { - auto dt = Add(clock_now, time); - - if (dt < clock_now) { - abort(); - } - - clock_now = dt; - } - - }; - - template - class Recorded - { - long time; - T value; - public: - Recorded(long time, T value) : time(time), value(value) { - } - long Time() const {return time;} - const T& Value() const {return value;} - }; - - template - bool operator == (Recorded lhs, Recorded rhs) { - return lhs.Time() == rhs.Time() && lhs.Value() == rhs.Value(); - } - - template - std::ostream& operator<< (std::ostream& out, const Recorded& r) { - out << "@" << r.Time() << "-" << r.Value(); - return out; - } - - class Subscription - { - long subscribe; - long unsubscribe; - - public: - explicit inline Subscription(long subscribe) : subscribe(subscribe), unsubscribe(std::numeric_limits::max()) { - } - inline Subscription(long subscribe, long unsubscribe) : subscribe(subscribe), unsubscribe(unsubscribe) { - } - inline long Subscribe() const {return subscribe;} - inline long Unsubscribe() const {return unsubscribe;} - }; - - inline bool operator == (Subscription lhs, Subscription rhs) { - return lhs.Subscribe() == rhs.Subscribe() && lhs.Unsubscribe() == rhs.Unsubscribe(); - } - - inline std::ostream& operator<< (std::ostream& out, const Subscription& s) { - out << s.Subscribe() << "-" << s.Unsubscribe(); - return out; - } - - template - struct Notification - { - typedef std::function OnNext; - typedef std::function OnCompleted; - typedef std::function OnError; - - virtual ~Notification() {} - - virtual void Out(std::ostream& out) =0; - virtual bool Equals(std::shared_ptr> other) = 0; - virtual void Accept(std::shared_ptr>) =0; - virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) =0; - - private: - struct OnNextNotification : public Notification { - OnNextNotification(T value) : value(std::move(value)) { - } - virtual void Out(std::ostream& out) { - out << "OnNext( " << value << ")"; - } - virtual bool Equals(std::shared_ptr> other) { - bool result = false; - other->Accept([this, &result](T value) { result = this->value == value;}, [](){}, [](std::exception_ptr){}); - return result; - } - virtual void Accept(std::shared_ptr> o) { - if (!o) { - abort(); - } - o->OnNext(value); - } - virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) { - if (!onnext || !oncompleted || !onerror) { - abort(); - } - onnext(value); - } - const T value; - }; - - struct OnCompletedNotification : public Notification { - OnCompletedNotification() { - } - virtual void Out(std::ostream& out) { - out << "OnCompleted()"; - } - virtual bool Equals(std::shared_ptr> other) { - bool result = false; - other->Accept([](T) {}, [&result](){result = true;}, [](std::exception_ptr){}); - return result; - } - virtual void Accept(std::shared_ptr> o) { - if (!o) { - abort(); - } - o->OnCompleted(); - } - virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) { - if (!onnext || !oncompleted || !onerror) { - abort(); - } - oncompleted(); - } - }; - - struct OnErrorNotification : public Notification { - OnErrorNotification(std::exception_ptr ep) : ep(ep) { - } - virtual void Out(std::ostream& out) { - out << "OnError()"; - } - virtual bool Equals(std::shared_ptr> other) { - bool result = false; - // not trying to compare exceptions - other->Accept([](T) {}, [](){}, [&result](std::exception_ptr){result = true;}); - return result; - } - virtual void Accept(std::shared_ptr> o) { - if (!o) { - abort(); - } - o->OnError(ep); - } - virtual void Accept(OnNext onnext, OnCompleted oncompleted, OnError onerror) { - if (!onnext || !oncompleted || !onerror) { - abort(); - } - onerror(ep); - } - const std::exception_ptr ep; - }; - - public: - static - std::shared_ptr CreateOnNext(T value) { - return std::make_shared(std::move(value)); - } - static - std::shared_ptr CreateOnCompleted() { - return std::make_shared(); - } - template - static - std::shared_ptr CreateOnError(Exception&& e) { - std::exception_ptr ep; - try {throw std::forward(e);} - catch (...) {ep = std::current_exception();} - return std::make_shared(ep); - } - static - std::shared_ptr CreateOnError(std::exception_ptr ep) { - return std::make_shared(ep); - } - }; - - template - bool operator == (std::shared_ptr> lhs, std::shared_ptr> rhs) { - if (!lhs && !rhs) {return true;} - if (!lhs || !rhs) {return false;} - return lhs->Equals(rhs); - } - - template - std::ostream& operator<< (std::ostream& out, const std::shared_ptr>& n) { - n->Out(out); - return out; - } - - template - struct TestableObserver : public Observer - { - virtual std::vector>>> Messages() =0; - }; - - template - struct TestableObservable : public Observable - { - virtual std::vector Subscriptions() =0; - - virtual std::vector>>> Messages() =0; - }; - - template - class TupleDispatch { - Target target; - public: - TupleDispatch(Target target) : target(std::move(target)) { - } - template - auto operator()(const Tuple& tuple) - -> decltype(util::tuple_dispatch(target, tuple)) { - return util::tuple_dispatch(target, tuple);} - template - auto operator()(const Tuple& tuple) const - -> decltype(util::tuple_dispatch(target, tuple)) { - return util::tuple_dispatch(target, tuple);} - }; - - template - TupleDispatch MakeTupleDispatch(Target&& target) { - return TupleDispatch(std::forward(target));} - - template - auto DispatchTuple(Tuple&& tuple, Target&& target) -> - decltype(util::tuple_dispatch(std::forward(target), std::forward(tuple))) { - return util::tuple_dispatch(std::forward(target), std::forward(tuple));} - -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto TieTuple(T&& t) -> - decltype(util::tuple_tie(std::forward(t))) { - return util::tuple_tie(std::forward(t));} -#endif //RXCPP_USE_VARIADIC_TEMPLATES - - template - class Subject; - - template - class BehaviorSubject; - - template - class AsyncSubject; - - template - class ConnectableSubject; - - template - class GroupedSubject; - - template - T item(const std::shared_ptr>&); - - template - T item(const std::shared_ptr>&); - - template - struct is_observable {static const bool value = false;}; - - template - struct is_observable>> {static const bool value = true;}; - - template - struct is_observable>> {static const bool value = true;}; - - template - struct is_observable>> {static const bool value = true;}; - - template - struct is_observable < std::shared_ptr < AsyncSubject> > {static const bool value = true; }; - - template - struct is_observable < std::shared_ptr < ConnectableSubject> > {static const bool value = true; }; - - template - struct is_observable>> {static const bool value = true;}; - - template - struct is_observable>> {static const bool value = true;}; - -namespace detail { - template - struct observable_item; - - template - struct observable_item>> {typedef T type;}; - - template - struct observable_item>> {typedef T type;}; - - template - struct observable_item < std::shared_ptr < ConnectableObservable> > {typedef T type; }; - - template - struct observable_item>> {typedef T type;}; -} - template - struct observable_item - { - typedef typename detail::observable_item::type>::type type; - }; - - template - struct observable_observer; - - template - struct observable_observer>> {typedef std::shared_ptr> type;}; - - template - struct observable_observer < std::shared_ptr < ConnectableObservable> > {typedef std::shared_ptr < Observer < T >> type; }; - - template - struct observable_observer>> {typedef std::shared_ptr> type;}; - - template - struct observer_item; - - template - struct observer_item>> {typedef T type;}; - - template - struct observer_item>> {typedef T type;}; - - template - struct subject_item; - - template - struct subject_item>> {typedef T type;}; - - template - struct subject_item>> {typedef T type;}; - - template - struct subject_item < std::shared_ptr < AsyncSubject> > {typedef T type; }; - - template - struct subject_item < std::shared_ptr < ConnectableSubject> > : subject_item {}; - - template - struct subject_item>> {typedef T type;}; - - template - struct subject_observer; - - template - struct subject_observer>> {typedef std::shared_ptr> type;}; - - template - struct subject_observer>> {typedef std::shared_ptr> type;}; - - template - struct subject_observer < std::shared_ptr < AsyncSubject> > {typedef std::shared_ptr < Observer < T >> type; }; - - template - struct subject_observer < std::shared_ptr < ConnectableSubject> > : subject_observer {}; - - template - struct subject_observable; - - template - struct subject_observable>> {typedef std::shared_ptr> type;}; - - template - struct subject_observable>> {typedef std::shared_ptr> type;}; - - template - struct subject_observable < std::shared_ptr < AsyncSubject> > {typedef std::shared_ptr < Observable < T >> type; }; - - template - struct subject_observable < std::shared_ptr < ConnectableSubject> > : subject_observable {}; - - template - std::shared_ptr> observable(const std::shared_ptr < Observable < T >> &o){ return o; } - - template - std::shared_ptr> observable(const std::shared_ptr < GroupedObservable < K, T >> &o){ return std::static_pointer_cast < Observable < T >> (o); } - - template - std::shared_ptr> observable(const std::shared_ptr < TestableObservable < T >> &o){ return std::static_pointer_cast < Observable < T >> (o); } - - template - std::shared_ptr< Observable < T >> observable(const std::shared_ptr < ConnectableObservable < T >> &o){ - return std::static_pointer_cast < Observable < T >> (o); } - - template - std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} - - template - std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} - - template - std::shared_ptr> observable(const std::shared_ptr < AsyncSubject < T >> &s){ return std::static_pointer_cast < Observable < T >> (s); } - - template - typename subject_observable::type observable(const std::shared_ptr < ConnectableSubject < Source, Subject >> &s){ - return std::static_pointer_cast < Observable < typename subject_item::type >> (s); } - - template - std::shared_ptr> observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} - - template - std::shared_ptr> observer(const std::shared_ptr < Observer < T >> &o){ return o; } - - template - std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} - - template - std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} - - template - std::shared_ptr> observer(const std::shared_ptr < AsyncSubject < T >> &s){ return std::static_pointer_cast < Observer < T >> (s); } - - template - void observer(const std::shared_ptr < ConnectableSubject < Source, Subject >> &s); // no observer - - template - std::shared_ptr> observer(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} - - template - std::shared_ptr> observer(const std::shared_ptr>& o){return std::static_pointer_cast>(o);} - - template - std::shared_ptr> grouped_observable(const std::shared_ptr>& s){return std::static_pointer_cast>(s);} -} -#endif diff --git a/Rx/CPP/src/cpprx/rx-includes.hpp b/Rx/CPP/src/cpprx/rx-includes.hpp deleted file mode 100644 index 4ef0221..0000000 --- a/Rx/CPP/src/cpprx/rx-includes.hpp +++ /dev/null @@ -1,100 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once - -#if !defined(CPPRX_RX_INCLUDES_HPP) -#define CPPRX_RX_INCLUDES_HPP - -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max - -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// some configuration macros -#if defined(_MSC_VER) - -#if _MSC_VER > 1600 -#define RXCPP_USE_RVALUEREF 1 -#endif - -#if _MSC_VER >= 1800 -#define RXCPP_USE_VARIADIC_TEMPLATES 1 -#endif - -#if _CPPRTTI -#define RXCPP_USE_RTTI 1 -#endif - -#elif defined(__clang__) - -#if __has_feature(cxx_rvalue_references) -#define RXCPP_USE_RVALUEREF 1 -#endif -#if __has_feature(cxx_rtti) -#define RXCPP_USE_RTTI 1 -#endif -#if __has_feature(cxx_variadic_templates) -#define RXCPP_USE_VARIADIC_TEMPLATES 1 -#endif - -#endif - -#if !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) -#define RXCPP_USE_WINRT 0 -#else -#define RXCPP_USE_WINRT 1 -#endif - -#if defined(RXCPP_FORCE_USE_VARIADIC_TEMPLATES) -#undef RXCPP_USE_VARIADIC_TEMPLATES -#define RXCPP_USE_VARIADIC_TEMPLATES RXCPP_FORCE_USE_VARIADIC_TEMPLATES -#endif - -#if defined(RXCPP_FORCE_USE_RVALUEREF) -#undef RXCPP_USE_RVALUEREF -#define RXCPP_USE_RVALUEREF RXCPP_FORCE_USE_RVALUEREF -#endif - -#if defined(RXCPP_FORCE_USE_RTTI) -#undef RXCPP_USE_RTTI -#define RXCPP_USE_RTTI RXCPP_FORCE_USE_RTTI -#endif - -#if defined(RXCPP_FORCE_USE_WINRT) -#undef RXCPP_USE_WINRT -#define RXCPP_USE_WINRT RXCPP_FORCE_USE_WINRT -#endif - -#include "rx-util.hpp" -#include "rx-base.hpp" -#include "rx-scheduler.hpp" -#include "rx-windows.hpp" -#include "rx-operators.hpp" -#include "rx-winrt.hpp" - -#pragma pop_macro("min") -#pragma pop_macro("max") - -#endif diff --git a/Rx/CPP/src/cpprx/rx-operators.hpp b/Rx/CPP/src/cpprx/rx-operators.hpp deleted file mode 100644 index cbef605..0000000 --- a/Rx/CPP/src/cpprx/rx-operators.hpp +++ /dev/null @@ -1,1018 +0,0 @@ - // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_OPERATORS_HPP) -#define CPPRX_RX_OPERATORS_HPP - -namespace rxcpp -{ - - ////////////////////////////////////////////////////////////////////// - // - // constructors - template - struct CreatedAutoDetachObserver : public Observer, public std::enable_shared_from_this> - { - std::shared_ptr> observer; - mutable std::atomic isStopped; - mutable SerialDisposable disposable; - - virtual ~CreatedAutoDetachObserver() { - if (!isStopped) { - abort(); - } - } - - CreatedAutoDetachObserver() - : isStopped(false) - { - } - - virtual void OnNext(const T& element) - { - if (!isStopped) { - auto keepAlive = this->shared_from_this(); - RXCPP_UNWIND(disposer, [&](){ - this->isStopped = true; - this->disposable.Dispose(); - }); - observer->OnNext(element); - disposer.dismiss(); - } - } - virtual void OnCompleted() - { - if (!isStopped.exchange(true)) { - auto keepAlive = this->shared_from_this(); - RXCPP_UNWIND(disposer, [&](){ - this->disposable.Dispose(); - }); - observer->OnCompleted(); - } - } - virtual void OnError(const std::exception_ptr& error) - { - if (!isStopped.exchange(true)) { - auto keepAlive = this->shared_from_this(); - RXCPP_UNWIND(disposer, [&](){ - this->disposable.Dispose(); - }); - observer->OnError(error); - } - } - - void Dispose() const { - isStopped = true; - disposable.Dispose(); - } - operator Disposable() const - { - // make sure to capture state and not 'this'. - auto local = this->shared_from_this(); - return Disposable([local]{ - local->Dispose(); - }); - } - - bool Fail(const std::exception_ptr& error) - { - if (!isStopped.exchange(true)) { - auto keepAlive = this->shared_from_this(); - RXCPP_UNWIND(disposer, [&](){ - this->disposable.Dispose(); - }); - observer->OnError(error); - return true; - } - return false; - } - }; - - template - std::shared_ptr> CreateAutoDetachObserver( - std::shared_ptr> observer - ) - { - auto p = std::make_shared>(); - p->observer = std::move(observer); - - return p; - } - - template - class CreatedObservable : public Observable - { - S subscribe; - - public: - CreatedObservable(S subscribe) - : subscribe(std::move(subscribe)) - { - } - virtual Disposable Subscribe(std::shared_ptr> observer) - { - auto autoDetachObserver = CreateAutoDetachObserver(std::move(observer)); - - if (CurrentThreadScheduler::IsScheduleRequired()) { - auto scheduler = std::make_shared(); - scheduler->Schedule( - [=](Scheduler::shared) -> Disposable { - try { - autoDetachObserver->disposable.Set(this->subscribe(autoDetachObserver)); - } catch (...) { - if (!autoDetachObserver->Fail(std::current_exception())) { - throw; - } - } - return Disposable::Empty(); - } - ); - return *autoDetachObserver; - } - try { - autoDetachObserver->disposable.Set(subscribe(autoDetachObserver)); - return *autoDetachObserver; - } catch (...) { - if (!autoDetachObserver->Fail(std::current_exception())) { - throw; - } - } - return *autoDetachObserver; - } - }; - - template - std::shared_ptr> CreateObservable(S subscribe) - { - return std::make_shared>(std::move(subscribe)); - } - - template - struct CreatedObserver : public Observer - { - std::function onNext; - std::function onCompleted; - std::function onError; - - virtual ~CreatedObserver() { - } - - virtual void OnNext(const T& element) - { - if(onNext) - { - onNext(element); - } - } - virtual void OnCompleted() - { - if(onCompleted) - { - onCompleted(); - } - } - virtual void OnError(const std::exception_ptr& error) - { - if(onError) - { - onError(error); - } - } - }; - - template - std::shared_ptr> CreateObserver( - std::function onNext, - std::function onCompleted = nullptr, - std::function onError = nullptr - ) - { - auto p = std::make_shared>(); - p->onNext = std::move(onNext); - p->onCompleted = std::move(onCompleted); - p->onError = std::move(onError); - - return p; - } - - - namespace detail - { - template - class Sink : public std::enable_shared_from_this - { - typedef std::shared_ptr> SinkObserver; - mutable util::maybe cancel; - - // need to prevent disposed observer from being - // deleted since it may still be in use on the stack - mutable SinkObserver expired; - protected: - mutable SinkObserver observer; - - public: - Sink(SinkObserver observerArg, Disposable cancelArg) : - observer(std::move(observerArg)) - { - cancel.set(std::move(cancelArg)); - if (!observer) - { - observer = std::make_shared>(); - } - } - - void Dispose() const - { - expired = std::make_shared>(); - using std::swap; - swap(observer, expired); - - if (cancel) - { - cancel->Dispose(); - cancel.reset(); - } - } - - Disposable GetDisposable() const - { - // make sure to capture state and not 'this'. - // usage means that 'this' will usualy be destructed - // immediately - auto local = this->shared_from_this(); - return Disposable([local]{ - local->Dispose(); - }); - } - }; - - template - class Producer : public std::enable_shared_from_this, public Observable - { - public: - typedef std::function SetSink; - typedef std::function, std::shared_ptr>, Disposable, SetSink)> Run; - private: - Run run; - struct State - { - SerialDisposable sink; - SerialDisposable subscription; - }; - public: - Producer(Run run) : - run(std::move(run)) - { - } - - virtual Disposable Subscribe(std::shared_ptr> observer) - { - auto state = std::make_shared(); - auto that = this->shared_from_this(); - if (CurrentThreadScheduler::IsScheduleRequired()) { - auto scheduler = std::make_shared(); - scheduler->Schedule([=](Scheduler::shared) -> Disposable - { - state->subscription.Set( - this->run(that, observer, state->subscription, [=](Disposable d) - { - state->sink.Set(std::move(d)); - })); - return Disposable::Empty(); - }); - } - else - { - state->subscription.Set( - run(that, observer, state->subscription, [=](Disposable d) - { - state->sink.Set(std::move(d)); - })); - } - return Disposable([=]() - { - state->sink.Dispose(); - state->subscription.Dispose(); - }); - } - }; - - } - - - struct SubjectState { - enum type { - Invalid, - Forwarding, - Completed, - Error - }; - }; - - template - class ObservableSubject : - public Base, - public std::enable_shared_from_this - { - protected: - std::mutex lock; - SubjectState::type state; - std::exception_ptr error; - std::vector>> observers; - - virtual ~ObservableSubject() { - // putting this first means that the observers - // will be destructed outside the lock - std::vector>> empty; - - std::unique_lock guard(lock); - using std::swap; - swap(observers, empty); - } - - ObservableSubject() : state(SubjectState::Forwarding) { - } - - void RemoveObserver(std::shared_ptr> toRemove) - { - std::unique_lock guard(lock); - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - *it = nullptr; - } - public: - - virtual Disposable Subscribe(std::shared_ptr> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - { - std::unique_lock guard(lock); - if (state == SubjectState::Completed) { - observer->OnCompleted(); - return Disposable::Empty(); - } else if (state == SubjectState::Error) { - observer->OnError(error); - return Disposable::Empty(); - } else { - for(auto& o : observers) - { - if (!o){ - o = std::move(observer); - return d; - } - } - observers.push_back(std::move(observer)); - return d; - } - } - } - }; - - template - class ObserverSubject : - public Observer, - public Base - { - public: - ObserverSubject() {} - - template - explicit ObserverSubject(A&& a) : Base(std::forward(a)) {} - - virtual void OnNext(const T& element) - { - std::unique_lock guard(Base::lock); - auto local = Base::observers; - guard.unlock(); - for(auto& o : local) - { - if (o) { - o->OnNext(element); - } - } - } - virtual void OnCompleted() - { - std::unique_lock guard(Base::lock); - Base::state = SubjectState::Completed; - auto local = std::move(Base::observers); - guard.unlock(); - for(auto& o : local) - { - if (o) { - o->OnCompleted(); - } - } - } - virtual void OnError(const std::exception_ptr& error) - { - std::unique_lock guard(Base::lock); - Base::state = SubjectState::Error; - Base::error = error; - auto local = std::move(Base::observers); - guard.unlock(); - for(auto& o : local) - { - if (o) { - o->OnError(error); - } - } - } - }; - - template - class Subject : - public ObserverSubject, Subject>> - { - }; - - template - std::shared_ptr> CreateSubject() - { - return std::make_shared>(); - } - - template - class GroupedObservableSubject : - public Base - { - K key; - public: - GroupedObservableSubject(K key) : key(std::move(key)) {} - - virtual K Key() {return key;} - }; - - template - class GroupedSubject : - public ObserverSubject, GroupedSubject>>> - { - typedef ObserverSubject, GroupedSubject>>> base; - public: - GroupedSubject(K key) : base(std::move(key)) {} - }; - - template - std::shared_ptr> CreateGroupedSubject(K key) - { - return std::make_shared>(std::move(key)); - } - - template - class BehaviorSubject : - public std::enable_shared_from_this>, - public Observable, - public Observer - { - std::mutex lock; - size_t slotCount; - T value; - SubjectState::type state; - util::maybe error; - std::vector>> observers; - - void RemoveObserver(std::shared_ptr> toRemove) - { - std::unique_lock guard(lock); - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - { - *it = nullptr; - ++slotCount; - } - } - - BehaviorSubject(); - public: - - typedef std::shared_ptr> shared; - - explicit BehaviorSubject(T t) : slotCount(0), value(std::move(t)), state(SubjectState::Forwarding) {} - - virtual ~BehaviorSubject() { - // putting this first means that the observers - // will be destructed outside the lock - std::vector>> empty; - - std::unique_lock guard(lock); - using std::swap; - swap(observers, empty); - } - - virtual Disposable Subscribe(std::shared_ptr> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - SubjectState::type localState = SubjectState::Invalid; - util::maybe localValue; - util::maybe localError; - { - std::unique_lock guard(lock); - - localState = state; - - if (state == SubjectState::Forwarding || localState == SubjectState::Completed) - { - localValue.set(value); - } - else if (localState == SubjectState::Error) - { - localError = error; - } - - if (state == SubjectState::Forwarding) - { - if (slotCount > 0) - { - for(auto& o : observers) - { - if (!o) - { - o = observer; - --slotCount; - break; - } - } - } - else - { - observers.push_back(observer); - } - } - } - - if (localState == SubjectState::Completed) { - observer->OnNext(*localValue.get()); - observer->OnCompleted(); - return Disposable::Empty(); - } - else if (localState == SubjectState::Error) { - observer->OnError(*localError.get()); - return Disposable::Empty(); - } - else if (localState == SubjectState::Forwarding) { - observer->OnNext(*localValue.get()); - } - - return d; - } - - virtual void OnNext(const T& element) - { - std::unique_lock guard(lock); - auto local = observers; - value = element; - guard.unlock(); - for(auto& o : local) - { - if (o) { - o->OnNext(element); - } - } - } - virtual void OnCompleted() - { - std::unique_lock guard(lock); - state = SubjectState::Completed; - auto local = std::move(observers); - guard.unlock(); - for(auto& o : local) - { - if (o) { - o->OnCompleted(); - } - } - } - virtual void OnError(const std::exception_ptr& errorArg) - { - std::unique_lock guard(lock); - state = SubjectState::Error; - error.set(errorArg); - auto local = std::move(observers); - guard.unlock(); - for(auto& o : local) - { - if (o) { - o->OnError(errorArg); - } - } - } - }; - - template - std::shared_ptr> CreateBehaviorSubject(Arg a) - { - return std::make_shared>(std::move(a)); - } - - template - class AsyncSubject : - public std::enable_shared_from_this>, - public Observable, - public Observer - { - std::mutex lock; - size_t slotCount; - util::maybe value; - SubjectState::type state; - util::maybe error; - std::vector < std::shared_ptr < Observer> > observers; - - void RemoveObserver(std::shared_ptr < Observer < T >> toRemove) - { - std::unique_lock guard(lock); - auto it = std::find(begin(observers), end(observers), toRemove); - if (it != end(observers)) - { - *it = nullptr; - ++slotCount; - } - } - - public: - - typedef std::shared_ptr> shared; - - AsyncSubject() : slotCount(0), value(), state(SubjectState::Forwarding) {} - - virtual ~AsyncSubject() { - // putting this first means that the observers - // will be destructed outside the lock - std::vector < std::shared_ptr < Observer> > empty; - - std::unique_lock guard(lock); - using std::swap; - swap(observers, empty); - } - - virtual Disposable Subscribe(std::shared_ptr < Observer < T >> observer) - { - std::weak_ptr> wptr = observer; - std::weak_ptr wself = this->shared_from_this(); - - Disposable d([wptr, wself]{ - if (auto self = wself.lock()) - { - self->RemoveObserver(wptr.lock()); - } - }); - - SubjectState::type localState = SubjectState::Invalid; - util::maybe localValue; - util::maybe localError; - { - std::unique_lock guard(lock); - - localState = state; - - if (localState == SubjectState::Completed) - { - localValue = value; - } - else if (localState == SubjectState::Error) - { - localError = error; - } - else if (state == SubjectState::Forwarding) - { - if (slotCount > 0) - { - for (auto& o : observers) - { - if (!o) - { - o = observer; - --slotCount; - break; - } - } - } - else - { - observers.push_back(observer); - } - } - } - - if (localState == SubjectState::Completed) { - if (localValue) { - observer->OnNext(*localValue.get()); - } - observer->OnCompleted(); - return Disposable::Empty(); - } - else if (localState == SubjectState::Error) { - observer->OnError(*localError.get()); - return Disposable::Empty(); - } - - return d; - } - - virtual void OnNext(const T& element) - { - std::unique_lock guard(lock); - if (state == SubjectState::Forwarding) { - value = element; - } - } - virtual void OnCompleted() - { - std::unique_lock guard(lock); - state = SubjectState::Completed; - auto local = std::move(observers); - auto localValue = value; - guard.unlock(); - for (auto& o : local) - { - if (o) { - if (localValue) { - o->OnNext(*localValue.get()); - } - o->OnCompleted(); - } - } - } - virtual void OnError(const std::exception_ptr& errorArg) - { - std::unique_lock guard(lock); - state = SubjectState::Error; - error.set(errorArg); - auto local = std::move(observers); - guard.unlock(); - for (auto& o : local) - { - if (o) { - o->OnError(errorArg); - } - } - } - }; - - template - std::shared_ptr> CreateAsyncSubject() - { - return std::make_shared>(); - } - - template - class ConnectableSubject : - public std::enable_shared_from_this>, - public ConnectableObservable::type> - { - private: - ConnectableSubject(); - - Source source; - Subject subject; - util::maybe subscription; - std::mutex lock; - - public: - virtual ~ConnectableSubject() {} - - ConnectableSubject(Source source, Subject subject) : source(source), subject(subject) - { - } - - virtual Disposable Connect() - { - std::unique_lock guard(lock); - if (!subscription) - { - subscription.set(source->Subscribe(observer(subject))); - } - auto that = this->shared_from_this(); - return Disposable([that]() - { - std::unique_lock guard(that->lock); - if (!!that->subscription) - { - that->subscription->Dispose(); - that->subscription.reset(); - } - }); - } - - virtual Disposable Subscribe(std::shared_ptr < Observer < typename subject_item::type >> observer) - { - return subject->Subscribe(observer); - } - }; - - template - struct fix0_thunk { - F f; - fix0_thunk(F&& f) : f(std::move(f)) - { - } - Disposable operator()(Scheduler::shared s) const - { - return f(s, *this); - } - }; - template - fix0_thunk fix0(F f) - { - return fix0_thunk(std::move(f)); - } -} - -////////////////////////////////////////////////////////////////////// -// -// imperative functions - -#include "operators/Subscribe.hpp" -#include "operators/ForEach.hpp" -#include "operators/Empty.hpp" -#include "operators/Never.hpp" -#include "operators/Return.hpp" -#include "operators/Throw.hpp" -#include "operators/Range.hpp" -#include "operators/Random.hpp" -#include "operators/Interval.hpp" -#include "operators/Iterate.hpp" -#include "operators/Using.hpp" - -////////////////////////////////////////////////////////////////////// -// -// standard query operators - -#include "operators/Select.hpp" -#include "operators/SelectMany.hpp" -#include "operators/Concat.hpp" -#include "operators/CombineLatest.hpp" -#include "operators/Zip.hpp" -#include "operators/Merge.hpp" -#include "operators/Where.hpp" -#include "operators/GroupBy.hpp" -#include "operators/Multicast.hpp" -#include "operators/Publish.hpp" -#include "operators/RefCount.hpp" -#include "operators/ConnectForever.hpp" -#include "operators/Scan.hpp" -#include "operators/Take.hpp" -#include "operators/Skip.hpp" -#include "operators/DistinctUntilChanged.hpp" -#include "operators/ToStdCollection.hpp" -#include "operators/ToAsync.hpp" -#include "operators/Materialize.hpp" -#include "operators/Dematerialize.hpp" - - -////////////////////////////////////////////////////////////////////// -// -// shift to Scheduler - -#include "operators/SubscribeOnObservable.hpp" -#include "operators/ObserveOnObserver.hpp" - - -////////////////////////////////////////////////////////////////////// -// -// time - -#include "operators/Delay.hpp" -#include "operators/Throttle.hpp" - -namespace rxcpp -{ - class StdQueueDispatcher - { - mutable std::queue> pending; - mutable std::condition_variable wake; - mutable std::mutex pendingLock; - - std::function get() const - { - std::function fn; - fn = std::move(pending.front()); - pending.pop(); - return std::move(fn); - } - - void dispatch(std::function fn) const - { - if (fn) - { - try { - fn(); - } - catch(...) { - std::unexpected(); - } - } - } - - public: - template - void post(Fn fn) const - { - { - std::unique_lock guard(pendingLock); - pending.push(std::move(fn)); - } - wake.notify_one(); - } - - void try_dispatch() const - { - std::function fn; - { - std::unique_lock guard(pendingLock); - if (!pending.empty()) - { - fn = get(); - } - } - dispatch(std::move(fn)); - } - - bool dispatch_one() const - { - std::function fn; - { - std::unique_lock guard(pendingLock); - wake.wait(guard, [this]{ return !pending.empty();}); - fn = get(); - } - bool result = !!fn; - dispatch(std::move(fn)); - return result; - } - }; -#if defined(OBSERVE_ON_DISPATCHER_OP) - typedef OBSERVE_ON_DISPATCHER_OP ObserveOnDispatcherOp; -#else - typedef StdQueueDispatcher ObserveOnDispatcherOp; -#endif - - template - std::shared_ptr> ObserveOnDispatcher( - const std::shared_ptr>& source) - { - auto dispatcher = std::make_shared(); - - return CreateObservable( - [=](std::shared_ptr> observer) - -> Disposable - { - auto cancel = std::make_shared(false); - - ComposableDisposable cd; - - cd.Add(Disposable([=]{ - *cancel = true; - })); - cd.Add(Subscribe( - source, - // on next - [=](const T& element) - { - dispatcher->post([=]{ - if (!*cancel) - observer->OnNext(element); - }); - }, - // on completed - [=] - { - dispatcher->post([=]{ - if(!*cancel) - observer->OnCompleted(); - }); - }, - // on error - [=](const std::exception_ptr& error) - { - dispatcher->post([=]{ - if (!*cancel) - observer->OnError(error); - }); - })); - return cd; - }); - } - -} - -#endif diff --git a/Rx/CPP/src/cpprx/rx-scheduler.hpp b/Rx/CPP/src/cpprx/rx-scheduler.hpp deleted file mode 100644 index ed69bf4..0000000 --- a/Rx/CPP/src/cpprx/rx-scheduler.hpp +++ /dev/null @@ -1,947 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_SCHEDULERS_HPP) -#define CPPRX_RX_SCHEDULERS_HPP - -namespace rxcpp -{ - - ////////////////////////////////////////////////////////////////////// - // - // schedulers - - struct CurrentThreadQueue - { - typedef Scheduler::clock clock; - typedef Scheduler::Work Work; - typedef ScheduledItem QueueItem; - - private: - ~CurrentThreadQueue(); - - struct compare_work - { - bool operator()(const QueueItem& work1, const QueueItem& work2) const { - return work1.due > work2.due; - } - }; - - typedef std::priority_queue< - QueueItem, - std::vector, - compare_work - > ScheduledWork; - - public: - struct ThreadLocalQueue { - Scheduler::shared scheduler; - ScheduledWork queue; - }; - - private: - static ThreadLocalQueue*& threadLocalQueue() { - RXCPP_THREAD_LOCAL static ThreadLocalQueue* queue; - return queue; - } - - public: - - static Scheduler::shared GetScheduler() { - return !!threadLocalQueue() ? threadLocalQueue()->scheduler : Scheduler::shared(); - } - static bool empty() { - if (!threadLocalQueue()) { - abort(); - } - return threadLocalQueue()->queue.empty(); - } - static ScheduledWork::const_reference top() { - if (!threadLocalQueue()) { - abort(); - } - return threadLocalQueue()->queue.top(); - } - static void pop() { - if (!threadLocalQueue()) { - abort(); - } - threadLocalQueue()->queue.pop(); - } - static void push(QueueItem item) { - if (!threadLocalQueue()) { - abort(); - } - threadLocalQueue()->queue.push(std::move(item)); - } - static void EnsureQueue(Scheduler::shared scheduler) { - if (!!threadLocalQueue()) { - abort(); - } - // create and publish new queue - threadLocalQueue() = new ThreadLocalQueue(); - threadLocalQueue()->scheduler = scheduler; - } - static std::unique_ptr CreateQueue(Scheduler::shared scheduler) { - std::unique_ptr result(new ThreadLocalQueue()); - result->scheduler = std::move(scheduler); - return result; - } - static void SetQueue(ThreadLocalQueue* queue) { - if (!!threadLocalQueue()) { - abort(); - } - // publish new queue - threadLocalQueue() = queue; - } - static void DestroyQueue(ThreadLocalQueue* queue) { - delete queue; - } - static void DestroyQueue() { - if (!threadLocalQueue()) { - abort(); - } - DestroyQueue(threadLocalQueue()); - threadLocalQueue() = nullptr; - } - }; - - struct CurrentThreadScheduler : public LocalScheduler - { - private: - CurrentThreadScheduler(const CurrentThreadScheduler&); - - struct Derecurser : public LocalScheduler - { - private: - Derecurser(const Derecurser&); - public: - Derecurser() - { - } - virtual ~Derecurser() - { - } - - static bool IsScheduleRequired() { return false; } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, work)); - - // work is disposable - return work; - } - }; - - public: - CurrentThreadScheduler() - { - } - virtual ~CurrentThreadScheduler() - { - } - - static bool IsScheduleRequired() { return !CurrentThreadQueue::GetScheduler(); } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto localScheduler = CurrentThreadQueue::GetScheduler(); - // check ownership - if (!!localScheduler) - { - // already has an owner - delegate - return localScheduler->Schedule(dueTime, std::move(work)); - } - - // take ownership - - CurrentThreadQueue::EnsureQueue(std::make_shared()); - RXCPP_UNWIND_AUTO([]{ - CurrentThreadQueue::DestroyQueue(); - }); - - CurrentThreadQueue::push(CurrentThreadQueue::QueueItem(dueTime, std::move(work))); - - // loop until queue is empty - for ( - auto dueTime = CurrentThreadQueue::top().due; - std::this_thread::sleep_until(dueTime), true; - dueTime = CurrentThreadQueue::top().due - ) - { - // dispatch work - auto work = CurrentThreadQueue::top().work; - - CurrentThreadQueue::pop(); - - Do(work, get()); - - if (CurrentThreadQueue::empty()) {break;} - } - - return Disposable::Empty(); - } - }; - - struct ImmediateScheduler : public LocalScheduler - { - private: - ImmediateScheduler(const ImmediateScheduler&); - - mutable std::mutex lock; - mutable bool hasFaulted; - mutable bool isAquired; - mutable CurrentThreadQueue::ThreadLocalQueue* queue; - public: - ImmediateScheduler() - : hasFaulted(false) - , isAquired(false) - , queue(nullptr) - { - } - virtual ~ImmediateScheduler() - { - } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto item = CurrentThreadQueue::QueueItem(dueTime, std::move(work)); - bool isOwner = false; - - { - std::unique_lock guard(lock); - if (!hasFaulted && !queue && !isAquired) - { - queue = CurrentThreadQueue::CreateQueue(this->shared_from_this()).release(); - isOwner = !isAquired; - isAquired = true; - } - } - - if (isOwner) - { - RXCPP_UNWIND_AUTO([&](){ - std::unique_lock guard(lock); - CurrentThreadQueue::DestroyQueue(queue); - queue = nullptr; - isAquired = false; - }); - - for(;;) - { - std::this_thread::sleep_until(item.due); - try - { - Do(item.work, queue->scheduler); - } - catch (...) - { - std::unique_lock guard(lock); - while (!queue->queue.empty()) {queue->queue.pop();} - hasFaulted = true; - throw; - } - - { - std::unique_lock guard(lock); - if (queue->queue.empty()) - { - break; - } - item = std::move(queue->queue.top()); - queue->queue.pop(); - } - } - return Disposable::Empty(); - } - else - { - std::unique_lock guard(lock); - queue->queue.push(item); - return item.work; - } - } - }; - - template - class ScheduledObserver : - public Observer, - public std::enable_shared_from_this> - { - typedef std::function Action; - - Scheduler::shared scheduler; - mutable std::shared_ptr> observer; - mutable SerialDisposable sd; - mutable std::queue queue; - mutable std::mutex lock; - mutable bool hasFaulted; - mutable bool isAquired; - - public: - ScheduledObserver(Scheduler::shared scheduler, std::shared_ptr> observer) - : scheduler(std::move(scheduler)) - , observer(std::move(observer)) - , hasFaulted(false) - , isAquired(false) - { - } - - void Dispose() const - { - sd.Dispose(); - } - operator Disposable() const - { - auto local = this->shared_from_this(); - return Disposable([local]{ - local->Dispose(); - }); - } - - virtual void OnNext(const T& element) - { - std::unique_lock guard(lock); - queue.push(Action([=](){ - this->observer->OnNext(std::move(element)); - })); - } - virtual void OnCompleted() - { - std::unique_lock guard(lock); - queue.push(Action([=](){ - this->observer->OnCompleted(); - })); - } - virtual void OnError(const std::exception_ptr& error) - { - std::unique_lock guard(lock); - queue.push(Action([=](){ - this->observer->OnError(std::move(error)); - })); - } - - void EnsureActive() - { - bool isOwner = false; - - { - std::unique_lock guard(lock); - if (!hasFaulted && !queue.empty()) - { - isOwner = !isAquired; - isAquired = true; - } - } - - if (isOwner) - { - auto keepAlive = this->shared_from_this(); - sd.Set(scheduler->Schedule( - [keepAlive](Scheduler::shared sched){ - return keepAlive->Run(sched);})); - } - } - - private: - Disposable Run(Scheduler::shared sched) - { - auto keepAlive = this->shared_from_this(); - - Action action; - { - std::unique_lock guard(lock); - if(!queue.empty()) - { - action = std::move(queue.front()); - queue.pop(); - } - else - { - isAquired = false; - return Disposable::Empty(); - } - } - - try - { - action(); - } - catch (...) - { - std::unique_lock guard(lock); - while (!queue.empty()) {queue.pop();} - hasFaulted = true; - throw; - } - - sd.Set(sched->Schedule( - [keepAlive](Scheduler::shared sched){ - return keepAlive->Run(sched);})); - return sd; - } - }; - - struct EventLoopScheduler : public LocalScheduler - { - private: - EventLoopScheduler(const EventLoopScheduler&); - - struct Derecurser : public std::enable_shared_from_this - { - private: - Derecurser(const Derecurser&); - - mutable bool isAquired; - mutable std::mutex lock; - mutable std::condition_variable wake; - CurrentThreadQueue::ThreadLocalQueue* queue; - - public: - Derecurser() - : isAquired(false) - { - } - virtual ~Derecurser() - { - } - - typedef std::function RunLoop; - typedef std::function Factory; - - static bool IsScheduleRequired() { return false; } - - typedef std::tuple, Disposable> EnsureThreadResult; - EnsureThreadResult EnsureThread(Factory& factory, Scheduler::shared owner, clock::time_point dueTime, Work work) - { - bool isOwner = false; - EnsureThreadResult result(util::maybe(), Disposable::Empty()); - - // work is disposable - std::get<1>(result) = work; - - std::unique_lock guard(lock); - - if (!isAquired) - { - RXCPP_UNWIND(unwindQueue, [&](){ - CurrentThreadQueue::DestroyQueue(queue); queue = nullptr;}); - queue = CurrentThreadQueue::CreateQueue(owner).release(); - - queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(work))); - - auto local = std::static_pointer_cast(shared_from_this()); - auto localQueue = queue; - std::get<0>(result).set(factory([local, localQueue] { - local->Run(localQueue);})); - - isOwner = !isAquired; - isAquired = true; - - // queue lifetime is now owned by the thread - unwindQueue.dismiss(); - } - - if (!isOwner) - { - queue->queue.push(CurrentThreadQueue::QueueItem(dueTime, std::move(work))); - wake.notify_one(); - } - - return std::move(result); - } - - private: - void Run(CurrentThreadQueue::ThreadLocalQueue* queue) throw() { - auto keepAlive = shared_from_this(); - { - std::unique_lock guard(lock); - - RXCPP_UNWIND_AUTO([&]{ - isAquired = false;}); - - RXCPP_UNWIND(unwindQueue, [&](){ - CurrentThreadQueue::DestroyQueue(); - queue = nullptr;}); - - CurrentThreadQueue::SetQueue(queue); - - while(!CurrentThreadQueue::empty()) - { - auto now = queue->scheduler->Now(); - if (CurrentThreadQueue::empty()) { - wake.wait(guard, [&](){ - return !CurrentThreadQueue::empty();}); - continue; - } - - auto item = &CurrentThreadQueue::top(); - if (!item->work) { - CurrentThreadQueue::pop(); continue;} - - // wait until the work is due - if (now < item->due) - { - wake.wait_until(guard, item->due); - continue; - } - // dispatch work - auto work = item->work; - - CurrentThreadQueue::pop(); - - RXCPP_UNWIND_AUTO([&]{ - guard.lock();}); - guard.unlock(); - LocalScheduler::Do(work, queue->scheduler); - } - } - } - }; - - std::thread worker; - Derecurser::Factory factory; - std::shared_ptr derecurser; - - public: - EventLoopScheduler() - : derecurser(std::make_shared()) - { - auto local = derecurser; - factory = [local] (Derecurser::RunLoop rl) -> std::thread { - return std::thread([local, rl]{rl();}); - }; - } - template - EventLoopScheduler(Factory factoryarg) - : factory(std::move(factoryarg)) - , derecurser(std::make_shared()) - { - } - virtual ~EventLoopScheduler() - { - if (worker.joinable()) { - worker.detach(); - } - } - - static bool IsScheduleRequired() { return !CurrentThreadQueue::GetScheduler(); } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto maybeThread = derecurser->EnsureThread(factory, this->shared_from_this(), dueTime, std::move(work)); - if (std::get<0>(maybeThread)) - { - if (worker.joinable()) - { - worker.join(); - } - worker = std::move(*std::get<0>(maybeThread).get()); - } - return std::move(std::get<1>(maybeThread)); - } - }; - - struct NewThreadScheduler : public LocalScheduler - { - public: - typedef std::function)> Factory; - private: - NewThreadScheduler(const NewThreadScheduler&); - - Factory factory; - public: - - - NewThreadScheduler() : factory([](std::function start){return std::thread(std::move(start));}) - { - } - NewThreadScheduler(Factory factory) : factory(factory) - { - } - virtual ~NewThreadScheduler() - { - } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto scheduler = std::make_shared(factory); - return scheduler->Schedule(dueTime, work); - } - }; - - template - class VirtualTimeScheduler : public VirtualTimeSchedulerBase - { - private: - VirtualTimeScheduler(const VirtualTimeScheduler&); - - typedef VirtualTimeSchedulerBase Base; - - typedef typename Base::QueueItem QueueItem; - - struct compare_work - { - bool operator()(const QueueItem& work1, const QueueItem& work2) const { - return work1.due > work2.due; - } - }; - - typedef std::priority_queue< - QueueItem, - std::vector, - compare_work - > ScheduledWork; - - ScheduledWork queue; - - public: - typedef typename Base::clock clock; - typedef typename Base::Work Work; - - virtual ~VirtualTimeScheduler() - { - } - - protected: - VirtualTimeScheduler() - { - } - explicit VirtualTimeScheduler(Absolute initialClock) - : Base(initialClock) - { - } - - virtual util::maybe GetNext() { - util::maybe next; - while (!queue.empty()) { - next.set(queue.top()); - if (!next->work) { - queue.pop(); - } - else { - return next; - } - } - return next; - } - - Disposable ScheduleAbsolute(Absolute dueTime, Work work) - { - Work cancelable; - - auto run = [cancelable, work](Scheduler::shared scheduler) -> Disposable { - auto local = work; - cancelable.Dispose(); - return Base::Do(local, std::move(scheduler)); - }; - - cancelable = run; - - auto si = QueueItem(dueTime, cancelable); - queue.push(si); - - return cancelable; - } - - }; - - class TestScheduler : public VirtualTimeScheduler - { - public: - typedef VirtualTimeScheduler Base; - typedef Base::clock clock; - typedef Base::Work Work; - typedef std::shared_ptr shared; - - static const long Created = 100; - static const long Subscribed = 200; - static const long Disposed = 1000; - - template - struct Messages - { - typedef Recorded>> RecordedT; - - static - RecordedT OnNext(long ticks, T value) - { - return RecordedT(ticks, Notification::CreateOnNext(value)); - } - - static - RecordedT OnCompleted(long ticks) - { - return RecordedT(ticks, Notification::CreateOnCompleted()); - } - - static - RecordedT OnError(long ticks, std::exception_ptr ep) - { - return RecordedT(ticks, Notification::CreateOnError(ep)); - } - - template - static - RecordedT OnError(long ticks, Exception e) - { - return RecordedT(ticks, Notification::CreateOnError(e)); - } - - static - Subscription Subscribe(long subscribe, long unsubscribe) - { - return Subscription(subscribe, unsubscribe); - } - - template - static - auto ToVector(const Item (&arr) [size]) -> std::vector { - return std::vector(std::begin(arr), std::end(arr)); - } - - private: - ~Messages(); - }; - - virtual Disposable ScheduleAbsolute(long dueTime, Work work) - { - if (dueTime <= Base::clock_now) - dueTime = Base::clock_now + 1; - - return Base::ScheduleAbsolute(dueTime, std::move(work)); - } - - virtual long Add(long absolute, long relative) - { - return absolute + relative; - } - - virtual clock::time_point ToTimePoint(long absolute) - { - return clock::time_point(clock::duration(absolute)); - } - - virtual long ToRelative(clock::duration d) - { - return static_cast(d.count()); - } - - using Base::Start; - - template - std::shared_ptr> Start(std::function>()> create, long created, long subscribed, long disposed) - { - auto observer = CreateObserver(); - - struct State - { - std::shared_ptr> source; - SerialDisposable subscription; - std::shared_ptr> observer; - }; - auto state = std::make_shared(); - - state->observer = observer; - - ScheduleAbsolute(created, [create, state](Scheduler::shared scheduler) -> Disposable { - state->source = create(); return Disposable::Empty(); }); - ScheduleAbsolute(subscribed, [state](Scheduler::shared scheduler) -> Disposable { - state->subscription.Set(state->source->Subscribe(state->observer)); return Disposable::Empty(); }); - ScheduleAbsolute(disposed, [state](Scheduler::shared scheduler) -> Disposable { - state->subscription.Dispose(); return Disposable::Empty(); }); - - Start(); - - return observer; - } - - template - std::shared_ptr> Start(std::function>()> create, long disposed) - { - return Start(create, Created, Subscribed, disposed); - } - - template - std::shared_ptr> Start(std::function>()> create) - { - return Start(create, Created, Subscribed, Disposed); - } - - template - std::shared_ptr> CreateHotObservable(std::vector>>> messages); - - template - std::shared_ptr> CreateColdObservable(std::vector>>> messages); - - template - std::shared_ptr> CreateObserver(); - }; - - template - class MockObserver : public TestableObserver - { - typedef Notification NotificationT; - typedef Recorded>> RecordedT; - - TestScheduler::shared scheduler; - std::vector messages; - - public: - MockObserver(TestScheduler::shared scheduler) - : scheduler(scheduler) - { - } - - virtual void OnNext(const T& value) - { - messages.push_back(RecordedT(scheduler->Clock(), NotificationT::CreateOnNext(value))); - } - - virtual void OnError(const std::exception_ptr& exception) - { - messages.push_back(RecordedT(scheduler->Clock(), NotificationT::CreateOnError(exception))); - } - - virtual void OnCompleted() - { - messages.push_back(RecordedT(scheduler->Clock(), NotificationT::CreateOnCompleted())); - } - - std::vector Messages() - { - return messages; - } - }; - - template - std::shared_ptr> TestScheduler::CreateObserver() - { - return std::make_shared>(std::static_pointer_cast(shared_from_this())); - } - - template - class ColdObservable : public TestableObservable, public std::enable_shared_from_this> - { - TestScheduler::shared scheduler; - typedef Recorded>> RecordedT; - std::vector messages; - std::vector subscriptions; - - public: - - ColdObservable(TestScheduler::shared scheduler, std::vector messages) - : scheduler(scheduler) - , messages(std::move(messages)) - { - } - - template - ColdObservable(TestScheduler::shared scheduler, Iterator begin, Iterator end) - : scheduler(scheduler) - , messages(begin, end) - { - } - - virtual Disposable Subscribe(std::shared_ptr> observer) - { - subscriptions.push_back(Subscription(scheduler->Clock())); - auto index = subscriptions.size() - 1; - - ComposableDisposable d; - - for (auto& message : messages) { - auto notification = message.Value(); - d.Add(scheduler->ScheduleRelative(message.Time(), [notification, observer](Scheduler::shared) -> Disposable { - notification->Accept(observer); return Disposable::Empty(); - })); - } - - auto sharedThis = this->shared_from_this(); - return Disposable([sharedThis, index, d]() { - sharedThis->subscriptions[index] = Subscription(sharedThis->subscriptions[index].Subscribe(), sharedThis->scheduler->Clock()); - d.Dispose(); - }); - } - - virtual std::vector Subscriptions() { - return subscriptions; - } - - virtual std::vector>>> Messages() { - return messages; - } - }; - - template - std::shared_ptr> TestScheduler::CreateColdObservable(std::vector>>> messages) - { - return std::make_shared>(std::static_pointer_cast(shared_from_this()), std::move(messages)); - } - - template - class HotObservable : public TestableObservable, public std::enable_shared_from_this> - { - TestScheduler::shared scheduler; - typedef Recorded>> RecordedT; - std::vector messages; - std::vector subscriptions; - std::vector>> observers; - - public: - - HotObservable(TestScheduler::shared scheduler, std::vector messages) - : scheduler(scheduler) - , messages(messages) - { - for (auto& message : messages) { - auto notification = message.Value(); - scheduler->ScheduleAbsolute(message.Time(), [this, notification](Scheduler::shared) -> Disposable { - auto local = this->observers; - for (auto& observer : local) { - notification->Accept(observer); - } - return Disposable::Empty(); - }); - } - } - - virtual Disposable Subscribe(std::shared_ptr> observer) - { - observers.push_back(observer); - subscriptions.push_back(Subscription(scheduler->Clock())); - auto index = subscriptions.size() - 1; - - auto sharedThis = this->shared_from_this(); - return Disposable([sharedThis, index, observer]() { - sharedThis->observers.erase(std::find(sharedThis->observers.begin(), sharedThis->observers.end(), observer)); - sharedThis->subscriptions[index] = Subscription(sharedThis->subscriptions[index].Subscribe(), sharedThis->scheduler->Clock()); - }); - } - - virtual std::vector Subscriptions() { - return subscriptions; - } - - virtual std::vector>>> Messages() { - return messages; - } - }; - - template - std::shared_ptr> TestScheduler::CreateHotObservable(std::vector>>> messages) - { - return std::make_shared>(std::static_pointer_cast(shared_from_this()), std::move(messages)); - } - -} - -#endif diff --git a/Rx/CPP/src/cpprx/rx-util.hpp b/Rx/CPP/src/cpprx/rx-util.hpp deleted file mode 100644 index 92ef223..0000000 --- a/Rx/CPP/src/cpprx/rx-util.hpp +++ /dev/null @@ -1,509 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_UTIL_HPP) -#define CPPRX_RX_UTIL_HPP - -#if !defined(RXCPP_THREAD_LOCAL) -#if defined(_MSC_VER) -#define RXCPP_THREAD_LOCAL __declspec(thread) -#else -#define RXCPP_THREAD_LOCAL __thread -#endif -#endif - -#if !defined(RXCPP_SELECT_ANY) -#if defined(_MSC_VER) -#define RXCPP_SELECT_ANY __declspec(selectany) -#else -#define RXCPP_SELECT_ANY -#endif -#endif - -#define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix -#define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) - -#define RXCPP_MAKE_IDENTIFIER(Prefix) RXCPP_CONCAT_EVALUATE(Prefix, __LINE__) - -namespace rxcpp { namespace util { - - template - struct identity - { - typedef Type type; - Type operator()(const Type& left) const {return left;} - }; - - template - class maybe - { - bool is_set; - typename std::aligned_storage::value>::type - storage; - public: - maybe() - : is_set(false) - { - } - - maybe(T value) - : is_set(false) - { - new (reinterpret_cast(&storage)) T(value); - is_set = true; - } - - maybe(const maybe& other) - : is_set(false) - { - if (other.is_set) { - new (reinterpret_cast(&storage)) T(*other.get()); - is_set = true; - } - } - maybe(maybe&& other) - : is_set(false) - { - if (other.is_set) { - new (reinterpret_cast(&storage)) T(std::move(*other.get())); - is_set = true; - other.reset(); - } - } - - ~maybe() - { - reset(); - } - - void reset() - { - if (is_set) { - is_set = false; - reinterpret_cast(&storage)->~T(); - } - } - - T* get() { - return is_set ? reinterpret_cast(&storage) : 0; - } - - const T* get() const { - return is_set ? reinterpret_cast(&storage) : 0; - } - - void set(T value) { - if (is_set) { - *reinterpret_cast(&storage) = std::move(value); - } else { - new (reinterpret_cast(&storage)) T(std::move(value)); - is_set = true; - } - } - - T& operator*() { return *get(); } - const T& operator*() const { return *get(); } - T* operator->() { return get(); } - const T* operator->() const { return get(); } - - maybe& operator=(const T& other) { - set(other); - return *this; - } - maybe& operator=(const maybe& other) { - if (const T* pother = other.get()) { - set(*pother); - } else { - reset(); - } - return *this; - } - - // boolean-like operators - operator T*() { return get(); } - operator const T*() const { return get(); } - - private: - - }; - - template - struct reveal_type {private: reveal_type();}; - -#if RXCPP_USE_VARIADIC_TEMPLATES - template - struct tuple_indices; - template <> - struct tuple_indices<-1> { // for an empty std::tuple<> there is no entry - typedef tuple_indices<> type; - }; - template - struct tuple_indices<0, Indices...> { // stop the recursion when 0 is reached - typedef tuple_indices<0, Indices...> type; - }; - template - struct tuple_indices { // recursively build a sequence of indices - typedef typename tuple_indices::type type; - }; - - template - struct make_tuple_indices { - typedef typename tuple_indices::value - 1>::type type; - }; - - namespace detail { - template - struct tuple_dispatch; - template - struct tuple_dispatch> { - template - static - auto call(F&& f, T&& t) - -> decltype (std::forward(f)(std::get(std::forward(t))...)) { - return std::forward(f)(std::get(std::forward(t))...); - } - };} - - template - auto tuple_dispatch(F&& f, T&& t) - -> decltype(detail::tuple_dispatch::type>::type>::call(std::forward(f), std::forward(t))) { - return detail::tuple_dispatch::type>::type>::call(std::forward(f), std::forward(t)); - } - - namespace detail { - template - struct tuple_tie; - template - struct tuple_tie> { - template - static - auto tie(T&& t) - -> decltype (std::tie(std::get(std::forward(t))...)) { - return std::tie(std::get(std::forward(t))...); - } - };} - - template - auto tuple_tie(T&& t) - -> decltype(detail::tuple_tie::type>::type>::tie(std::forward(t))) { - return detail::tuple_tie::type>::type>::tie(std::forward(t)); - } - - struct as_tuple { - template - auto operator()(AsTupleNext... x) - -> decltype(std::make_tuple(std::move(x)...)) { - return std::make_tuple(std::move(x)...);} - template - auto operator()(AsTupleNext... x) const - -> decltype(std::make_tuple(std::move(x)...)) { - return std::make_tuple(std::move(x)...);} - }; -#else - namespace detail { - template - struct tuple_dispatch; - template<> - struct tuple_dispatch<0> { - template - static auto call(F&& f, T&& ) - -> decltype (std::forward(f)()) { - return std::forward(f)();} - }; - template<> - struct tuple_dispatch<1> { - template - static auto call(F&& f, T&& t) - -> decltype (std::forward(f)(std::get<0>(std::forward(t)))) { - return std::forward(f)(std::get<0>(std::forward(t)));} - }; - template<> - struct tuple_dispatch<2> { - template - static auto call(F&& f, T&& t) - -> decltype (std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)))) { - return std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)));} - }; - template<> - struct tuple_dispatch<3> { - template - static auto call(F&& f, T&& t) - -> decltype (std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)), - std::get<2>(std::forward(t)))) { - return std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)), - std::get<2>(std::forward(t)));} - }; - template<> - struct tuple_dispatch<4> { - template - static auto call(F&& f, T&& t) - -> decltype (std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)), - std::get<2>(std::forward(t)), - std::get<3>(std::forward(t)))) { - return std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)), - std::get<2>(std::forward(t)), - std::get<3>(std::forward(t)));} - }; - template<> - struct tuple_dispatch<5> { - template - static auto call(F&& f, T&& t) - -> decltype (std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)), - std::get<2>(std::forward(t)), - std::get<3>(std::forward(t)), - std::get<4>(std::forward(t)))) { - return std::forward(f)( - std::get<0>(std::forward(t)), - std::get<1>(std::forward(t)), - std::get<2>(std::forward(t)), - std::get<3>(std::forward(t)), - std::get<4>(std::forward(t)));} - }; - } - - template - auto tuple_dispatch(F&& f, T&& t) - -> decltype(detail::tuple_dispatch::type>::value>::call(std::forward(f), std::forward(t))) { - return detail::tuple_dispatch::type>::value>::call(std::forward(f), std::forward(t)); - } - - struct as_tuple { - auto operator()() - -> decltype(std::make_tuple()) { - return std::make_tuple();} - template - auto operator()(AsTupleNext x) - -> decltype(std::make_tuple(std::move(x))) { - return std::make_tuple(std::move(x));} - template< - class AsTupleNext1, - class AsTupleNext2> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2) - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2))) { - return std::make_tuple( - std::move(x1), - std::move(x2));} - template< - class AsTupleNext1, - class AsTupleNext2, - class AsTupleNext3> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2, - AsTupleNext3 x3) - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3))) { - return std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3));} - template< - class AsTupleNext1, - class AsTupleNext2, - class AsTupleNext3, - class AsTupleNext4> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2, - AsTupleNext3 x3, - AsTupleNext4 x4) - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4))) { - return std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4));} - template< - class AsTupleNext1, - class AsTupleNext2, - class AsTupleNext3, - class AsTupleNext4, - class AsTupleNext5> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2, - AsTupleNext3 x3, - AsTupleNext4 x4, - AsTupleNext5 x5) - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4), - std::move(x5))) { - return std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4), - std::move(x5));} - - auto operator()() const - -> decltype(std::make_tuple()) { - return std::make_tuple();} - template - auto operator()(AsTupleNext x) const - -> decltype(std::make_tuple(std::move(x))) { - return std::make_tuple(std::move(x));} - template< - class AsTupleNext1, - class AsTupleNext2> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2) const - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2))) { - return std::make_tuple( - std::move(x1), - std::move(x2));} - template< - class AsTupleNext1, - class AsTupleNext2, - class AsTupleNext3> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2, - AsTupleNext3 x3) const - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3))) { - return std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3));} - template< - class AsTupleNext1, - class AsTupleNext2, - class AsTupleNext3, - class AsTupleNext4> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2, - AsTupleNext3 x3, - AsTupleNext4 x4) const - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4))) { - return std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4));} - template< - class AsTupleNext1, - class AsTupleNext2, - class AsTupleNext3, - class AsTupleNext4, - class AsTupleNext5> - auto operator()( - AsTupleNext1 x1, - AsTupleNext2 x2, - AsTupleNext3 x3, - AsTupleNext4 x4, - AsTupleNext5 x5) const - -> decltype(std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4), - std::move(x5))) { - return std::make_tuple( - std::move(x1), - std::move(x2), - std::move(x3), - std::move(x4), - std::move(x5));} - }; -#endif //RXCPP_USE_VARIADIC_TEMPLATES - - struct pass_through { - template - typename std::decay::type operator()(X&& x) {return std::forward(x);} - template - typename std::decay::type operator()(X&& x) const {return std::forward(x);} - }; - - struct pass_through_second { - template - typename std::decay::type operator()(X&& , Y&& y) {return std::forward(y);} - template - typename std::decay::type operator()(X&& , Y&& y) const {return std::forward(y);} - }; - - template - class unwinder - { - public: - ~unwinder() - { - if (!!function) - { - try { - (*function)(); - } catch (...) { - std::unexpected(); - } - } - } - - explicit unwinder(Function* functionArg) - : function(functionArg) - { - } - - void dismiss() - { - function = nullptr; - } - - private: - unwinder(); - unwinder(const unwinder&); - unwinder& operator=(const unwinder&); - - Function* function; - }; - -}} - -#define RXCPP_UNWIND(Name, Function) \ - RXCPP_UNWIND_EXPLICIT(uwfunc_ ## Name, Name, Function) - -#define RXCPP_UNWIND_AUTO(Function) \ - RXCPP_UNWIND_EXPLICIT(RXCPP_MAKE_IDENTIFIER(uwfunc_), RXCPP_MAKE_IDENTIFIER(unwind_), Function) - -#define RXCPP_UNWIND_EXPLICIT(FunctionName, UnwinderName, Function) \ - auto FunctionName = (Function); \ - rxcpp::util::unwinder UnwinderName(std::addressof(FunctionName)) - -#endif \ No newline at end of file diff --git a/Rx/CPP/src/cpprx/rx-windows.hpp b/Rx/CPP/src/cpprx/rx-windows.hpp deleted file mode 100644 index 06b2fb9..0000000 --- a/Rx/CPP/src/cpprx/rx-windows.hpp +++ /dev/null @@ -1,282 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_WINDOWS_HPP) -#define CPPRX_RX_WINDOWS_HPP -#pragma once - -#if (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) && (defined(WINDOWS) || defined(WIN32) || defined(_WIN32)) - -#pragma comment(lib, "user32.lib") - -#define NOMINMAX -#include - -namespace rxcpp { namespace win32 { - - -#if !defined(OBSERVE_ON_DISPATCHER_OP) -#define OBSERVE_ON_DISPATCHER_OP rxcpp::win32::ObserveOnDispatcherOp -#endif - - struct ObserveOnDispatcherOp - { - HWND hwnd; - - ObserveOnDispatcherOp(): hwnd(WindowClass::Instance().CreateWindow_()) - { - if (!hwnd) - throw std::exception("error"); - } - ~ObserveOnDispatcherOp() - { - // send one last message to ourselves to shutdown. - post([=]{ CloseWindow(hwnd); }); - } - - struct WindowClass - { - static const wchar_t* const className(){ return L"ObserveOnDispatcherOp::WindowClass"; } - WindowClass() - { - WNDCLASS wndclass = {}; - wndclass.style = 0; - wndclass.lpfnWndProc = &WndProc; - wndclass.cbClsExtra; - wndclass.cbWndExtra = 0; - wndclass.hInstance = NULL; - wndclass.lpszClassName = className(); - - if (!RegisterClass(&wndclass)) - throw std::exception("error"); - - } - HWND CreateWindow_() - { - return CreateWindowEx(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, 0); - } - static const int WM_USER_DISPATCH = WM_USER + 1; - - static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) - { - switch (message) - { - // TODO: shatter attack surface. should validate the message, e.g. using a handle table. - case WM_USER_DISPATCH: - ((void(*)(void*))wParam)((void*)lParam); - return 0; - default: - return DefWindowProc(hwnd, message, wParam, lParam); - } - } - static WindowClass& Instance() { - static WindowClass instance; - return instance; - } - }; - - template - void post(Fn fn) const - { - std::unique_ptr f(new Fn(fn)); - ::PostMessage(hwnd, WindowClass::WM_USER_DISPATCH, (WPARAM)(void(*)(void*))&run_proc, (LPARAM)(void*)f.release()); - } - template - static void run_proc( - void* pvfn - ) - { - std::unique_ptr f((Fn*)(void*) pvfn); - (*f.get())(); - } - }; - - class WindowScheduler : public rxcpp::LocalScheduler - { - - struct compare_work - { - template - bool operator()(const T& work1, const T& work2) const { - return work1.first > work2.first; - } - }; - - struct Queue; - - typedef std::pair Item; - typedef std::pair> PriorityItem; - - typedef std::priority_queue< - PriorityItem, - std::vector, - compare_work - > ScheduledWork; - - struct Queue - { - Queue() : exit(false), window(NULL) {} - bool exit; - HWND window; - ScheduledWork scheduledWork; - mutable std::mutex lock; - }; - - struct WindowClass - { - std::shared_ptr queue; - - static const wchar_t* const className(){ return L"rxcpp::win32::WindowScheduler::WindowClass"; } - WindowClass() - { - } - - static void Create(const std::shared_ptr& queue) - { - WNDCLASSW wndclass = {}; - wndclass.style = 0; - wndclass.lpfnWndProc = &WndProc; - wndclass.cbWndExtra = 0; - wndclass.hInstance = NULL; - wndclass.lpszClassName = className(); - - RegisterClassW(&wndclass); - - std::unique_ptr that(new WindowClass); - that->queue = queue; - - queue->window = CreateWindowExW(0, WindowClass::className(), L"MessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, reinterpret_cast(that.get())); - if (!queue->window) - throw std::exception("create window failed"); - - that.release(); - } - - static const int WM_USER_DISPATCH = WM_USER + 1; - - static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) throw() - { - WindowClass* windowClass = reinterpret_cast(GetWindowLongPtr(hwnd, GWLP_USERDATA)); - switch (message) - { - case WM_NCCREATE: - { - windowClass = reinterpret_cast(reinterpret_cast(lParam)->lpCreateParams); - SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast(reinterpret_cast(windowClass))); - } - break; - case WM_NCDESTROY: - { - delete windowClass; - SetWindowLongPtr(hwnd, GWLP_USERDATA, 0L); - } - break; - case WM_TIMER: - case WM_USER_DISPATCH: - { - bool destroy = false; - HWND window = NULL; - std::vector> expired; - { - std::unique_lock guard(windowClass->queue->lock); - - while (!windowClass->queue->scheduledWork.empty() && !windowClass->queue->scheduledWork.top().second.get()->second) - { - // discard the disposed items - expired.push_back(windowClass->queue->scheduledWork.top().second); - windowClass->queue->scheduledWork.pop(); - } - - if (!windowClass->queue->scheduledWork.empty()) - { - auto& item = windowClass->queue->scheduledWork.top(); - auto now = item.second.get()->first->Now(); - - // wait until the work is due - if(now < item.first) - { - auto remaining = std::chrono::duration_cast(item.first - now).count(); - if (remaining >= USER_TIMER_MINIMUM) - { - return SetTimer(hwnd, 0, static_cast(remaining), nullptr); - } - std::this_thread::sleep_until(item.first); - } - - // dispatch work - auto work = std::move(item.second.get()->second); - auto scheduler = std::move(item.second.get()->first); - windowClass->queue->scheduledWork.pop(); - - { - RXCPP_UNWIND_AUTO([&]{guard.lock();}); - guard.unlock(); - LocalScheduler::Do(work, scheduler); - work = nullptr; - scheduler = nullptr; - } - - if (!windowClass->queue->scheduledWork.empty()) - { - ::PostMessageW(windowClass->queue->window, WindowClass::WM_USER_DISPATCH, 0, 0); - } - } - - destroy = windowClass->queue->exit && windowClass->queue->scheduledWork.empty(); - window = windowClass->queue->window; - } - - if (destroy) - { - DestroyWindow(window); - } - } - return 0; - default: - break; - } - return DefWindowProcW(hwnd, message, wParam, lParam); - } - }; - std::shared_ptr queue; - - public: - WindowScheduler() - : queue(std::make_shared()) - { - WindowClass::Create(queue); - } - ~WindowScheduler() - { - // send one last message to ourselves to shutdown. - { - std::unique_lock guard(queue->lock); - queue->exit = true; - } - ::PostMessageW(queue->window, WindowClass::WM_USER_DISPATCH, 0, 0); - } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto cancelable = std::make_shared(std::make_pair(get(), std::move(work))); - { - std::unique_lock guard(queue->lock); - queue->scheduledWork.push(std::make_pair(dueTime, cancelable)); - } - ::PostMessageW(queue->window, WindowClass::WM_USER_DISPATCH, 0, 0); - auto local = queue; - return Disposable([local, cancelable]{ - std::unique_lock guard(local->lock); - cancelable.get()->second = nullptr; - ::PostMessageW(local->window, WindowClass::WM_USER_DISPATCH, 0, 0); - }); - } - }; -} } - -#endif - -#endif diff --git a/Rx/CPP/src/cpprx/rx-winrt.hpp b/Rx/CPP/src/cpprx/rx-winrt.hpp deleted file mode 100644 index 061e351..0000000 --- a/Rx/CPP/src/cpprx/rx-winrt.hpp +++ /dev/null @@ -1,667 +0,0 @@ -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_WINRT_HPP) -#define CPPRX_RX_WINRT_HPP -#pragma once - -#if RXCPP_USE_WINRT - -#define NOMINMAX -#include - -namespace rxcpp { namespace winrt { - namespace wf = Windows::Foundation; - namespace wuicore = Windows::UI::Core; - namespace wuixaml = Windows::UI::Xaml; - namespace wuictrls = Windows::UI::Xaml::Controls; - - template - struct EventPattern - { - EventPattern(TSender sender, TEventArgs eventargs) : - sender(sender), - eventargs(eventargs) - {} - - TSender Sender() const { - return sender;}; - TEventArgs EventArgs() const { - return eventargs;}; - - private: - TSender sender; - TEventArgs eventargs; - }; - - namespace detail - { - template - struct is_typed_event_handler : public std::false_type {}; - - template - struct is_typed_event_handler> : public std::true_type {}; - - template - struct get_sender; - template - struct get_sender> - { - typedef Sender type; - }; - - template - struct get_eventargs; - template - struct get_eventargs> - { - typedef EventArgs type; - }; - - template - struct get_eventpattern; - template - struct get_eventpattern> - { - typedef EventPattern type; - }; - - template - struct remove_ref { typedef T type; }; - template - struct remove_ref { typedef T type; }; - template - struct remove_ref { typedef T type; }; - template - struct remove_ref { typedef T type; }; - - template - wf::IAsyncOperation^ operation_interface(wf::IAsyncOperation^ i) { return i; } - - template - wf::IAsyncOperationWithProgress^ operation_interface(wf::IAsyncOperationWithProgress^ i) { return i; } - } - - template - auto FromEventPattern( - std::function addHandler, - std::function removeHandler) - -> typename std::enable_if < !detail::is_typed_event_handler::value, std::shared_ptr < Observable < EventPattern < Platform::Object^, EventArgs^ >> >> ::type - { - typedef EventPattern EP; - return CreateObservable( - [=](std::shared_ptr> observer) - { - auto h = ref new EventHandler( - [=](Platform::Object^ sender, EventArgs^ args) -> void - { - observer->OnNext(EP(sender, args)); - }); - - auto token = addHandler(h); - - return Disposable( - [removeHandler, token]() - { - removeHandler(token); - }); - }); - } - - template - auto FromEventPattern( - std::function addHandler, - std::function removeHandler) - -> typename std::enable_if < !detail::is_typed_event_handler::value, std::shared_ptr < Observable < EventPattern < Sender^, EventArgs^ >> >> ::type - { - typedef EventPattern EP; - return CreateObservable( - [=](std::shared_ptr> observer) - { - auto h = ref new EventHandler( - [=](Platform::Object^ sender, EventArgs^ args) -> void - { - observer->OnNext(EP(dynamic_cast(sender), args)); - }); - - auto token = addHandler(h); - - return Disposable( - [removeHandler, token]() - { - removeHandler(token); - }); - }); - } - - template - auto FromEventPattern( - std::function addHandler, - std::function removeHandler) - -> typename std::enable_if < detail::is_typed_event_handler::value, std::shared_ptr < Observable < typename detail::get_eventpattern::type> >> ::type - { - typedef typename detail::get_eventpattern::type EP; - return CreateObservable( - [=](std::shared_ptr < Observer < EP >> observer) - { - auto h = ref new SpecificTypedEventHandler( - [=](typename detail::get_sender::type sender, typename detail::get_eventargs::type args) -> void - { - observer->OnNext(EP(sender, args)); - }); - - auto token = addHandler(h); - - return Disposable( - [removeHandler, token]() - { - removeHandler(token); - }); - }); - } - - template - auto FromAsyncPattern(F&& start) - -> std::function < std::shared_ptr < Observable< decltype(start((*(T*)nullptr)...)->GetResults()) >> (const T&...)> - { - typedef decltype(start((*(T*)nullptr)...)->GetResults()) Result; - - return [=](const T&... t) - { - auto subject = CreateAsyncSubject(); - auto o = start(t...); - typedef typename detail::remove_ref< decltype(o->Completed)>::type Handler; - typedef decltype(detail::operation_interface(o)) Interface; - o->Completed = ref new Handler([=](Interface io, wf::AsyncStatus) - { - util::maybe value; - try - { - value.set(io->GetResults()); - } - catch (...) - { - subject->OnError(std::current_exception()); - return; - } - subject->OnNext(*value.get()); - subject->OnCompleted(); - }); - return observable(subject); - }; - } - - std::shared_ptr < Observable < size_t> > - inline DispatcherInterval( - Scheduler::clock::duration interval) - { - return CreateObservable( - [=](std::shared_ptr < Observer < size_t >> observer) - -> Disposable - { - size_t cursor = 0; - ComposableDisposable cd; - - wf::TimeSpan timeSpan; - // convert to 100ns ticks - timeSpan.Duration = static_cast(std::chrono::duration_cast(interval).count() / 100); - - auto dispatcherTimer = ref new wuixaml::DispatcherTimer(); - dispatcherTimer->Interval = timeSpan; - - cd.Add(Subscribe(FromEventPattern, Platform::Object>( - [dispatcherTimer](wf::EventHandler^ h) { - return dispatcherTimer->Tick += h; }, - [dispatcherTimer](wf::EventRegistrationToken t) { - dispatcherTimer->Tick -= t; - }), - [observer, cursor](EventPattern) mutable { - observer->OnNext(cursor); - ++cursor; - }, - [observer]() { - observer->OnCompleted(); - }, - [observer](std::exception_ptr e) { - observer->OnError(e); - })); - - cd.Add(Disposable( - [observer, dispatcherTimer](){ - dispatcherTimer->Stop(); - observer->OnCompleted(); - })); - - dispatcherTimer->Start(); - - return cd; - }); - } - - struct CoreDispatcherScheduler : public LocalScheduler - { - private: - CoreDispatcherScheduler(const CoreDispatcherScheduler&); - - public: - CoreDispatcherScheduler(wuicore::CoreDispatcher^ dispatcher, wuicore::CoreDispatcherPriority priority = wuicore::CoreDispatcherPriority::Normal) - : dispatcher(dispatcher) - , priority(priority) - { - } - virtual ~CoreDispatcherScheduler() - { - } - - typedef std::shared_ptr shared; - - static shared Current() - { - auto window = wuixaml::Window::Current; - if (window == nullptr) - { - throw std::logic_error("No window current"); - } - auto d = window->Dispatcher; - if (d == nullptr) - { - throw std::logic_error("No dispatcher on current window"); - } - return std::make_shared(d); - } - - wuicore::CoreDispatcher^ Dispatcher() - { - return dispatcher; - } - - wuicore::CoreDispatcherPriority Priority() - { - return priority; - } - - using LocalScheduler::Schedule; - virtual Disposable Schedule(clock::time_point dueTime, Work work) - { - auto that = shared_from_this(); - auto dispatchAsync = [this, that, work](Scheduler::shared sched) mutable -> Disposable - { - dispatcher->RunAsync( - priority, - ref new wuicore::DispatchedHandler( - [that, this, work]() mutable - { - this->Do(work, that); - }, - Platform::CallbackContext::Any - )); - return Disposable::Empty(); - }; - - auto now = Now(); - auto interval = dueTime - now; - if (now > dueTime || interval < std::chrono::milliseconds(10)) - { - return dispatchAsync(nullptr); - } - - wf::TimeSpan timeSpan; - // convert to 100ns ticks - timeSpan.Duration = static_cast(std::chrono::duration_cast(interval).count() / 100); - - auto dispatcherTimer = ref new wuixaml::DispatcherTimer(); - // convert to 100ns ticks - dispatcherTimer->Interval = timeSpan; - - auto result = Subscribe(FromEventPattern, Platform::Object>( - [dispatcherTimer](wf::EventHandler^ h) { - return dispatcherTimer->Tick += h; }, - [dispatcherTimer](wf::EventRegistrationToken t) { - dispatcherTimer->Tick -= t; - }), - [dispatchAsync, dispatcherTimer](EventPattern) mutable { - dispatcherTimer->Stop(); - dispatchAsync(nullptr); - }); - - dispatcherTimer->Start(); - - return result; - } - - private: - wuicore::CoreDispatcher^ dispatcher; - wuicore::CoreDispatcherPriority priority; - }; - - template - class ReactiveCommand : public Observable - { - typedef ReactiveCommand This; - - std::mutex flight_lock; - std::shared_ptr < Subject> inflight; - std::shared_ptr < Subject> exceptions; - std::shared_ptr> executed; - Scheduler::shared defaultScheduler; - bool allowsConcurrentExecution; - std::shared_ptr < Observable < bool >> isExecuting; - std::shared_ptr < Observable < bool >> canExecuteObservable; - - public: - typedef std::shared_ptr shared; - - ReactiveCommand(std::shared_ptr < Observable < bool >> canExecute = nullptr, bool allowsConcurrentExecution = false, Scheduler::shared scheduler = nullptr, bool initialCondition = true) : - inflight(std::make_shared < Subject < bool >> ()), - exceptions(std::make_shared < Subject >()), - executed(std::make_shared < Subject < T >> ()), - defaultScheduler(scheduler), - allowsConcurrentExecution(allowsConcurrentExecution) - { - if (!canExecute) - { - canExecute = Return(true); - } - - if (!defaultScheduler) - { - defaultScheduler = std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()); - } - - isExecuting = observable(from(inflight) - .observe_on(defaultScheduler) - .scan(0, [](int balanced, bool in) { - return in ? balanced + 1 : balanced - 1; }) - .select([](int balanced) { - return balanced > 0; }) - .publish(false) - .connect_forever() - .distinct_until_changed()); - - auto isBusy = allowsConcurrentExecution ? Return(false) : isExecuting; - auto canExecuteAndNotBusy = from(isBusy) - .combine_latest([](bool b, bool ce) - { - return ce && !b; - }, canExecute); - - auto canExecuteObs = from(canExecuteAndNotBusy) - .publish(initialCondition) - .ref_count(); - - canExecuteObservable = observable(from(canExecuteObs) - .distinct_until_changed() - .observe_on(defaultScheduler)); - } - - template - auto RegisterAsync(F f) - -> decltype(f(*(T*) nullptr)) - { - return observable(from(executed) - .select_many( - // select collection - [=](T t) - { - std::unique_lock guard(this->flight_lock); - this->inflight->OnNext(true); - return Using( - // resource factory - [=]() -> SerialDisposable - { - SerialDisposable flight; - flight.Set(ScheduledDisposable( - this->defaultScheduler, - Disposable([=]() - { - std::unique_lock guard(this->flight_lock); - this->inflight->OnNext(false); - }))); - return flight; - }, - // observable factory - [=](SerialDisposable) - { - return f(t); - }); - }) - .observe_on(defaultScheduler) - .publish() - .connect_forever()); - } - - template - auto RegisterAsyncFunction(F f, Scheduler::shared scheduler = nullptr) - -> std::shared_ptr> - { - auto asyncFunc = ToAsync(f, scheduler); - return RegisterAsync(asyncFunc); - } - - bool AllowsConcurrentExecution() - { - return allowsConcurrentExecution; - } - - std::shared_ptr> ThrownExceptions() - { - return from(exceptions).observe_on(defaultScheduler); - } - - std::shared_ptr> IsExecuting() - { - return isExecuting; - } - - std::shared_ptr> CanExecuteObservable() - { - return canExecuteObservable; - } - - Disposable Subscribe(std::shared_ptr < Observer < T >> observer) - { - return from(executed) - .subscribe( - //on next - [=](const T& t){ - try - { - observer->OnNext(t); - } - catch (...) - { - this->exceptions->OnError(std::current_exception()); - } - }, - //on completed - [=](){ - try - { - observer->OnCompleted(); - } - catch (...) - { - this->exceptions->OnError(std::current_exception()); - } - }, - //on error - [=](std::exception_ptr e){ - try - { - observer->OnError(e); - } - catch (...) - { - this->exceptions->OnError(std::current_exception()); - } - }); - } - - void Execute(T value) - { - { - std::unique_lock guard(flight_lock); - inflight->OnNext(true); - } - executed->OnNext(value); - { - std::unique_lock guard(flight_lock); - inflight->OnNext(false); - } - } - }; - - template - std::shared_ptr> observable(std::shared_ptr < ReactiveCommand < T >> s){ return std::static_pointer_cast < Observable < T >> (s); } - - template - Disposable BindCommand(wuictrls::Button^ button, std::shared_ptr> command) - { - typedef rxrt::EventPattern RoutedEventPattern; - - ComposableDisposable cd; - - cd.Add(from(command->CanExecuteObservable()) - .subscribe( - [=](bool b) - { - button->IsEnabled = b; - })); - - auto click = rxrt::FromEventPattern( - [=](wuixaml::RoutedEventHandler^ h) - { - return button->Click += h; - }, - [=](wf::EventRegistrationToken t) - { - button->Click -= t; - }); - - cd.Add(from(click) - .subscribe([=](RoutedEventPattern ep) - { - command->Execute(ep); - })); - - return cd; - } - - template - struct OperationPattern - { - typedef decltype(((O)nullptr)->GetDeferral()) D; - - OperationPattern(O operation) : - operation(operation), - deferral(operation->GetDeferral()) - { - } - - O Operation() const { - return operation; - }; - D Deferral() const { - return deferral; - }; - - void Dispose() - { - deferral->Complete(); - } - - operator Disposable() const - { - // make sure to capture state and not 'this'. - // usage means that 'this' will usualy be destructed - // immediately - auto local = deferral; - return Disposable([local]{ - local->Complete(); - }); - } - - private: - O operation; - D deferral; - }; - - template - OperationPattern make_operation_pattern(O o) - { - return OperationPattern(std::move(o)); - } - - - namespace detail - { - - template - auto DeferOperation(const std::shared_ptr < Observable < T >> &source, SOp sop, SOb sob, Scheduler::shared scheduler = nullptr) - -> decltype(sob(*(OperationPattern*)nullptr, *(T*) nullptr)) - { - typedef decltype(sob(*(OperationPattern*)nullptr, *(T*) nullptr)) ResultObservable; - typedef typename observable_item::type Result; - if (!scheduler) - { - scheduler = std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()); - } - return rx::CreateObservable( - [=](const std::shared_ptr < Observer < Result >> &observer) - { - return from(source) - .select_many( - //select observable - [=](T t) -> ResultObservable - { - // must take the deferral early while the event is still on the stack. - auto op = make_operation_pattern(sop(t)); - typedef decltype(op) OP; - - return Using( - // resource factory - [=]() - { - return op; - }, - // observable factory - [sob, t](OP op) - { - return sob(op, t); - }); - }) - .observe_on(scheduler) - .subscribe( - //on next - [=](Result r) - { - observer->OnNext(r); - }, - //on completed - [=]() - { - observer->OnCompleted(); - }, - //on error - [=](std::exception_ptr e) - { - observer->OnError(e); - } - ); - }); - } - } - - struct defer_operation {}; - template - auto rxcpp_chain(defer_operation && , const std::shared_ptr < Observable < T >> &source, SOp sop, SOb sob, Scheduler::shared scheduler = nullptr) - -> decltype(detail::DeferOperation(source, sop, sob, scheduler)) - { - return detail::DeferOperation(source, sop, sob, scheduler); - } - -} } - -#endif - -#endif diff --git a/Rx/CPP/src/cpprx/rx.hpp b/Rx/CPP/src/cpprx/rx.hpp deleted file mode 100644 index 16bfcc1..0000000 --- a/Rx/CPP/src/cpprx/rx.hpp +++ /dev/null @@ -1,587 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -#pragma once -#include "rx-includes.hpp" - -#if !defined(CPPRX_RX_HPP) -#define CPPRX_RX_HPP - -namespace rxcpp -{ - template - class Binder; - - template - class Binder>; - -namespace detail { - template - struct observable_item> {typedef typename rxcpp::observable_item::type type;}; -} - - template - struct is_observable < Binder > {static const bool value = true; }; - - template - class BinderBase - { - protected: - Obj obj; - template - friend V observable(const BinderBase& b); - - public: - typedef T item_type; - typedef Obj observable_type; - - BinderBase(Obj obj) : obj(std::move(obj)) - { - } - - Observable* operator->() const { - return obj.get(); - } - }; - - template - Obj observable(const BinderBase& b) { - return b.obj; - } - - template - class BinderNested; - - template - class BinderNested : public Base - { - protected: - typedef typename Base::item_type item_type; - using Base::obj; - public: - static const bool is_item_observable = false; - BinderNested(Obj obj) : Base(std::move(obj)) - { - } - - void select_many(); - void concat(); - }; - - template - class BinderNested : public Base - { - protected: - typedef typename Base::item_type item_type; - using Base::obj; - public: - static const bool is_item_observable = true; - - BinderNested(Obj obj) : Base(std::move(obj)) - { - } - - auto select_many() - -> decltype(from(SelectMany(obj, util::pass_through(), util::pass_through_second()))) { - return from(SelectMany(obj, util::pass_through(), util::pass_through_second())); - } - auto concat() - -> decltype(from(Concat(*(Obj*)nullptr))) { - return from(Concat(obj)); - } - }; - - template - class BinderConnectable : public Base - { - protected: - typedef typename Base::item_type item_type; - using Base::obj; - public: - BinderConnectable(Obj obj) : Base(std::move(obj)) - { - } - }; - - template - class BinderConnectable>> : public Base - { - protected: - typedef typename Base::item_type item_type; - using Base::obj; - public: - BinderConnectable(std::shared_ptr> obj) : Base(std::move(obj)) - { - } - - auto ref_count() - -> decltype(from(RefCount(obj))) { - return from(RefCount(obj)); - } - auto connect_forever() - -> decltype(from(ConnectForever(obj))) { - return from(ConnectForever(obj)); - } - }; - - template - class BinderMaterialized : public Base - { - protected: - typedef typename Base::item_type item_type; - using Base::obj; - public: - BinderMaterialized(Obj obj) : Base(std::move(obj)) - { - } - }; - - template - class BinderMaterialized>>>> : public Base - { - protected: - typedef typename Base::item_type item_type; - using Base::obj; - public: - BinderMaterialized(std::shared_ptr>>> obj) : Base(std::move(obj)) - { - } - - auto dematerialize() - -> decltype(from(Dematerialize(observable(obj)))) { - return from(Dematerialize(observable(obj))); - } - }; - - template - class Binder : public BinderNested< - BinderConnectable< - BinderMaterialized< - BinderBase::type, Obj>, - typename observable_item::type, - Obj - >, - typename observable_item::type, - Obj - >, - typename observable_item::type, - Obj, - is_observable::type>::value> - { - typedef BinderNested< - BinderConnectable< - BinderMaterialized< - BinderBase::type, Obj>, - typename observable_item::type, - Obj - >, - typename observable_item::type, - Obj - >, - typename observable_item::type, - Obj, - is_observable::type>::value> base; - typedef typename base::item_type item_type; - using base::obj; - public: - - Binder(Obj obj) : base(std::move(obj)) - { - } - - template - auto select(S selector) -> decltype(from(Select(obj, selector))) { - return from(Select(obj, selector)); - } - using base::select_many; - template - auto select_many(CS collectionSelector) - -> decltype(from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second()))) { - return from(SelectMany(obj, std::move(collectionSelector), util::pass_through_second())); - } - template - auto select_many(CS collectionSelector, RS resultSelector) - -> decltype(from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector)))) { - return from(SelectMany(obj, std::move(collectionSelector), std::move(resultSelector))); - } -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto merge(const MergeSource&... source) - -> decltype(from(Merge(obj, observable(source)...))) { - return from(Merge(obj, observable(source)...)); - } -#else - template - auto merge(const MergeSource& source) - -> decltype(from(Merge(obj, observable(source)))) { - return from(Merge(obj, observable(source))); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto zip(S selector, const ZipSource&... source) - -> decltype(from(Zip(selector, obj, observable(source)...))) { - return from(Zip(selector, obj, observable(source)...)); - } - template - auto zip(const Zip1Source&... source) - -> decltype(from(Zip(util::as_tuple(), obj, observable(source)...))) { - return from(Zip(util::as_tuple(), obj, observable(source)...)); - } -#else - template - auto zip(S selector, const ZipSource& source) - -> decltype(from(Zip(selector, obj, observable(source)))) { - return from(Zip(selector, obj, observable(source))); - } - template - auto zip(const Zip1Source& source) - -> decltype(from(Zip(util::as_tuple(), obj, observable(source)))) { - return from(Zip(util::as_tuple(), obj, observable(source))); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES -#if RXCPP_USE_VARIADIC_TEMPLATES - private: - struct selector_tag{}; - struct source_tag{}; - template - auto combine_latest_detail(selector_tag&&, CombineSelector&& selector, const CombineSelectorSources&... sources) - -> decltype(from(CombineLatest(std::forward(selector), obj, observable(sources)...))) { - return from(CombineLatest(std::forward(selector), obj, observable(sources)...)); - } - template - auto combine_latest_detail(source_tag&&, const CombineSourceSources&... sources) - -> decltype(from(CombineLatest(util::as_tuple(), obj, observable(sources)...))) { - return from(CombineLatest(util::as_tuple(), obj, observable(sources)...)); - } - public: - template - auto combine_latest(CombineSourceOrSelector&& sourceOrSelector, const CombineSourceN&... sourcen) - -> decltype(from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), sourcen...))) { - return from(combine_latest_detail(typename std::conditional::type>::value, source_tag, selector_tag>::type(), std::forward(sourceOrSelector), sourcen...)); - } -#else - template - auto combine_latest(S selector, const CombineLSource& source) - -> decltype(from(CombineLatest(selector, obj, observable(source)))) { - return from(CombineLatest(selector, obj, observable(source))); - } - template - auto combine_latest(const CombineLSource& source) - -> decltype(from(CombineLatest(util::as_tuple(), obj, observable(source)))) { - return from(CombineLatest(util::as_tuple(), obj, observable(source))); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES - - using base::concat; -#if RXCPP_USE_VARIADIC_TEMPLATES - template - auto concat(const ConcatSource&... source) - -> decltype(from(Concat(Iterate(std::vector())))) { - std::vector sources; - sources.push_back(obj); - std::make_tuple((sources.push_back(observable(source)), true)...); - return from(Concat(Iterate(std::move(sources)))); - } -#else - template - auto concat(const ConcatSource& source) - -> decltype(from(Concat(Iterate(std::vector())))) { - std::vector sources; - sources.push_back(obj); - sources.push_back(observable(source)); - return from(Concat(Iterate(std::move(sources)))); - } -#endif //RXCPP_USE_VARIADIC_TEMPLATES - template - auto concat(Range range) - -> decltype(from(Concat(Iterate(range.insert(range.begin(), range.front()), range)))) { - range.insert(range.begin(), obj); - return from(Concat(Iterate(std::move(range)))); - } - template - auto where(P predicate) -> decltype(from(Where(obj, predicate))) { - return from(Where(obj, predicate)); - } - template - auto group_by( - KS keySelector) - -> decltype(from(GroupBy(obj, keySelector, util::pass_through(), std::less()))) { - return from(GroupBy(obj, keySelector, util::pass_through(), std::less())); - } - template - auto group_by( - KS keySelector, - VS valueSelector) - -> decltype(from(GroupBy(obj, keySelector, valueSelector, std::less()))) { - return from(GroupBy(obj, keySelector, valueSelector, std::less())); - } - template - auto group_by( - KS keySelector, - VS valueSelector, - L less) - -> decltype(from(GroupBy(obj, keySelector, valueSelector, less))) { - return from(GroupBy(obj, keySelector, valueSelector, less)); - } - template - auto scan(Seed seed, A accumulator) - -> decltype(from(Scan(obj, seed, accumulator))) { - return from(Scan(obj, seed, accumulator)); - } - template - auto scan(A accumulator) - -> decltype(from(Scan(obj, accumulator))) { - return from(Scan(obj, accumulator)); - } - template - auto take(Integral n) - -> decltype(from(Take(obj, n))) { - return from(Take(obj, n)); - } - template - auto take_until(const TakeUntilTerminus& terminus) - -> decltype(from(TakeUntil(obj, observable(terminus)))) { - return from(TakeUntil(obj, observable(terminus))); - } - template - auto skip(Integral n) - -> decltype(from(Skip(obj, n))) { - return from(Skip(obj, n)); - } - template - auto skip_until(const SkipUntilTerminus& terminus) - -> decltype(from(SkipUntil(obj, observable(terminus)))) { - return from(SkipUntil(obj, observable(terminus))); - } - template - auto multicast(MulticastSubject subject) - -> decltype(from(Multicast(observable(obj), subject))) { - return from(Multicast(observable(obj), subject)); - } - auto publish() - -> decltype(from(Publish(observable(obj)))) { - return from(Publish(observable(obj))); - } - auto publish(item_type value) - -> decltype(from(Publish(observable(obj), value))) { - return from(Publish(observable(obj), value)); - } - auto publish_last() - -> decltype(from(PublishLast(observable(obj)))) { - return from(PublishLast(observable(obj))); - } - templateclass Allocator> - auto to_vector() - -> decltype(from(ToStdCollection>>(obj))) { - return from(ToStdCollection>>(obj)); - } - auto to_vector() - -> decltype(from(ToStdCollection>(obj))) { - return from(ToStdCollection>(obj)); - } - templateclass Allocator> - auto to_list() - -> decltype(from(ToStdCollection>>(obj))) { - return from(ToStdCollection>>(obj)); - } - auto to_list() - -> decltype(from(ToStdCollection>(obj))) { - return from(ToStdCollection>(obj)); - } - auto materialize() - -> decltype(from(Materialize(observable(obj)))) { - return from(Materialize(observable(obj))); - } - auto delay(Scheduler::clock::duration due, Scheduler::shared scheduler) -> decltype(from(Delay(obj, due, scheduler))) { - return from(Delay(obj, due, scheduler)); - } - auto throttle(Scheduler::clock::duration due, Scheduler::shared scheduler) - -> decltype(from(Throttle(obj, due, scheduler))) { - return from(Throttle(obj, due, scheduler)); - } - auto distinct_until_changed() -> decltype(from(DistinctUntilChanged(obj))) { - return from(DistinctUntilChanged(obj)); - } - auto subscribe_on(Scheduler::shared scheduler) - -> decltype(from(SubscribeOnObservable(obj, std::move(scheduler)))) - { - return from(SubscribeOnObservable(obj, std::move(scheduler))); - } - auto observe_on(Scheduler::shared scheduler) - -> decltype(from(ObserveOnObserver(obj, std::move(scheduler)))) - { - return from(ObserveOnObserver(obj, std::move(scheduler))); - } -#if RXCPP_USE_WINRT - auto observe_on_dispatcher() - -> decltype(from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current())))) - { - return from(ObserveOnObserver(obj, std::static_pointer_cast(winrt::CoreDispatcherScheduler::Current()))); - } -#else - auto on_dispatcher() - -> decltype(from(ObserveOnDispatcher(obj))) - { - return from(ObserveOnDispatcher(obj)); - } -#endif - template - void for_each(OnNext onNext) { - ForEach(obj, onNext); - } - auto subscribe(std::shared_ptr> observer) -> decltype(obj->Subscribe(observer)) { - return obj->Subscribe(observer); - } - template - auto subscribe(OnNext onNext) -> decltype(Subscribe(obj, onNext)) { - auto result = Subscribe(obj, onNext); - return result; - } - template - auto subscribe(OnNext onNext, OnComplete onComplete) - -> decltype(Subscribe(obj, onNext, onComplete)) { - auto result = Subscribe(obj, onNext, onComplete); - return result; - } - template - auto subscribe(OnNext onNext, OnComplete onComplete, OnError onError) - -> decltype(Subscribe(obj, onNext, onComplete, onError)) { - auto result = Subscribe(obj, onNext, onComplete, onError); - return result; - } -#if RXCPP_USE_VARIADIC_TEMPLATE - template - auto chain(ChainArg&&... arg) - -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)...))) { - return from(rxcpp_chain(Tag(), obj, std::forward(arg)...)); - } -#else - template - auto chain() - -> decltype(from(rxcpp_chain(Tag(), obj))) { - return from(rxcpp_chain(Tag(), obj)); - } - template - auto chain(ChainArg&& arg) - -> decltype(from(rxcpp_chain(Tag(), obj, std::forward(arg)))) { - return from(rxcpp_chain(Tag(), obj, std::forward(arg))); - } - template - auto chain( - ChainArg1&& arg1, - ChainArg2&& arg2) - -> decltype(from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2)))) { - return from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2))); - } - template - auto chain( - ChainArg1&& arg1, - ChainArg2&& arg2, - ChainArg3&& arg3) - -> decltype(from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2), - std::forward(arg3)))) { - return from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2), - std::forward(arg3))); - } - template - auto chain( - ChainArg1&& arg1, - ChainArg2&& arg2, - ChainArg3&& arg3, - ChainArg4&& arg4) - -> decltype(from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2), - std::forward(arg3), - std::forward(arg4)))) { - return from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2), - std::forward(arg3), - std::forward(arg4))); - } - template - auto chain( - ChainArg1&& arg1, - ChainArg2&& arg2, - ChainArg3&& arg3, - ChainArg4&& arg4, - ChainArg5&& arg5) - -> decltype(from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2), - std::forward(arg3), - std::forward(arg4), - std::forward(arg5)))) { - return from(rxcpp_chain(Tag(), obj, - std::forward(arg1), - std::forward(arg2), - std::forward(arg3), - std::forward(arg4), - std::forward(arg5))); - } -#endif - }; - - template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } - - template - Binder < std::shared_ptr < ConnectableObservable> > from(std::shared_ptr < ConnectableObservable < T >> obj) { - return Binder < std::shared_ptr < ConnectableObservable> >(std::move(obj)); } - - template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } - - template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(observable(obj)); } - - template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(observable(obj)); } - - template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } - - template - Binder>> from(std::shared_ptr> obj) { - return Binder>>(std::move(obj)); } - - template - Binder from(Binder binder) { - return std::move(binder); } - - template - T item(const Binder>>&); - - template - T item(const Binder>>&); -} - -#endif diff --git a/Rx/CPP/test/operators/Merge.cpp b/Rx/CPP/test/operators/Merge.cpp deleted file mode 100644 index 7e26d8f..0000000 --- a/Rx/CPP/test/operators/Merge.cpp +++ /dev/null @@ -1,60 +0,0 @@ -#include "cpprx/rx.hpp" -namespace rx=rxcpp; - -#include "catch.hpp" - -SCENARIO("merge issue 5", "[merge][issue][operators]"){ - GIVEN("Empty and Never"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - WHEN("merged 4 times"){ - - std::vector empty; - auto o = rx::observable(rx::from(rx::Iterate(empty)) - .merge(rx::Never())); - - auto res1 = scheduler->Start( - [o]() { - return o; - } - ); - auto res2 = scheduler->Start( - [o]() { - return o; - } - ); - auto res3 = scheduler->Start( - [o]() { - return o; - } - ); - auto res4 = scheduler->Start( - [o]() { - return o; - } - ); - - THEN("1 - the output is empty and subscribed"){ - std::vector required; - auto actual = res1->Messages(); - REQUIRE(required == actual); - } - THEN("2 - the output is empty and subscribed"){ - std::vector required; - auto actual = res2->Messages(); - REQUIRE(required == actual); - } - THEN("3 - the output is empty and subscribed"){ - std::vector required; - auto actual = res3->Messages(); - REQUIRE(required == actual); - } - THEN("4 - the output is empty and subscribed"){ - std::vector required; - auto actual = res4->Messages(); - REQUIRE(required == actual); - } - } - } -} diff --git a/Rx/CPP/test/operators/Publish.cpp b/Rx/CPP/test/operators/Publish.cpp deleted file mode 100644 index 26e6e5b..0000000 --- a/Rx/CPP/test/operators/Publish.cpp +++ /dev/null @@ -1,111 +0,0 @@ -#include "cpprx/rx.hpp" -namespace rx=rxcpp; - -#include "catch.hpp" - -SCENARIO("publish_last", "[publish_last][publish][multicast][operators]"){ - GIVEN("a test hot observable of longs"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(110, 7), - m::OnNext(220, 3), - m::OnNext(280, 4), - m::OnNext(290, 1), - m::OnNext(340, 8), - m::OnNext(360, 5), - m::OnNext(370, 6), - m::OnNext(390, 7), - m::OnNext(410, 13), - m::OnNext(430, 2), - m::OnNext(450, 9), - m::OnNext(520, 11), - m::OnNext(560, 20), - m::OnCompleted(600) - }; - return m::ToVector(messages); - }() - ); - - auto res = scheduler->CreateObserver(); - - rx::SerialDisposable subscription; - std::shared_ptr> ys; - - WHEN("subscribed and then connected"){ - - scheduler->ScheduleAbsolute(rx::TestScheduler::Created, - [&invoked, &ys, &xs](rx::Scheduler::shared) { - ys = rx::observable(rx::from(xs) - .publish_last()); - return rx::Disposable::Empty(); - }); - - scheduler->ScheduleAbsolute(rx::TestScheduler::Subscribed, [&subscription, &ys, &res](rx::Scheduler::shared) { - subscription.Set(ys->Subscribe(res)); - return rx::Disposable::Empty(); - }); - - scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&subscription](rx::Scheduler::shared) { - subscription.Dispose(); - return rx::Disposable::Empty(); - }); - - auto connection = std::make_shared(); - scheduler->ScheduleAbsolute(300, [connection, &ys](rx::Scheduler::shared) { - connection->Set(ys->Connect()); - return rx::Disposable::Empty(); - }); - scheduler->ScheduleAbsolute(400, [connection](rx::Scheduler::shared) { - connection->Dispose(); - return rx::Disposable::Empty(); - }); - - connection = std::make_shared(); - scheduler->ScheduleAbsolute(500, [connection, &ys](rx::Scheduler::shared) { - connection->Set(ys->Connect()); - return rx::Disposable::Empty(); - }); - scheduler->ScheduleAbsolute(550, [connection](rx::Scheduler::shared) { - connection->Dispose(); - return rx::Disposable::Empty(); - }); - - connection = std::make_shared(); - scheduler->ScheduleAbsolute(650, [connection, &ys](rx::Scheduler::shared) { - connection->Set(ys->Connect()); - return rx::Disposable::Empty(); - }); - scheduler->ScheduleAbsolute(800, [connection](rx::Scheduler::shared) { - connection->Dispose(); - return rx::Disposable::Empty(); - }); - - scheduler->Start(); - - THEN("the output is empty"){ - std::vector required; - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there were 3 subscription/unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(300, 400), - m::Subscribe(500, 550), - m::Subscribe(650, 800) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - diff --git a/Rx/CPP/test/operators/Return.cpp b/Rx/CPP/test/operators/Return.cpp deleted file mode 100644 index 44c38cf..0000000 --- a/Rx/CPP/test/operators/Return.cpp +++ /dev/null @@ -1,119 +0,0 @@ -#include "cpprx/rx.hpp" -namespace rx=rxcpp; - -#include "catch.hpp" - -SCENARIO("return basic", "[return][operators]"){ - GIVEN("return 42"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - auto res = scheduler->Start( - [=]() { - return rx::Return(42, scheduler); - } - ); - - WHEN("started"){ - - THEN("the output is 42"){ - m::RecordedT items[] = { - m::OnNext(201, 42), - m::OnCompleted(201) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("return disposed", "[return][operators]"){ - GIVEN("test scheduler"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - WHEN("return 42 after disposed"){ - auto res = scheduler->Start( - [&]() { - return rx::Return(42, scheduler); - }, - 200 - ); - - THEN("the output is empty"){ - std::vector required; - auto actual = res->Messages(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("return disposed after next", "[return][operators]"){ - GIVEN("return 42 after disposal"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - rx::SerialDisposable d; - - auto xs = rx::Return(42, scheduler); - - auto res = scheduler->CreateObserver(); - - scheduler->ScheduleAbsolute( - 100, - [&](rx::Scheduler::shared) { - d.Set(from(xs).subscribe( - [&](int x){ - d.Dispose(); res->OnNext(x);}, - [&](){ - res->OnCompleted();}, - [&](std::exception_ptr ex){ - res->OnError(ex);})); - return d; - } - ); - - WHEN("started"){ - - scheduler->Start(); - - THEN("the output is 42"){ - m::RecordedT items[] = { - m::OnNext(101, 42) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("return observer throws", "[return][operators]"){ - GIVEN("return 42"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - auto xs = rx::Return(42, scheduler); - - WHEN("subscribed to onnext that throws"){ - from(xs).subscribe([](int){ throw std::runtime_error("onnext throws"); }); - - THEN("the exception is not supressed"){ - REQUIRE_THROWS(scheduler->Start()); - } - } - - WHEN("subscribed to oncompleted that throws"){ - from(xs).subscribe([](int){},[](){ throw std::runtime_error("oncompleted throws"); }); - - THEN("the exception is not supressed"){ - REQUIRE_THROWS(scheduler->Start()); - } - } - } -} - diff --git a/Rx/CPP/test/operators/Select.cpp b/Rx/CPP/test/operators/Select.cpp deleted file mode 100644 index 2de7f21..0000000 --- a/Rx/CPP/test/operators/Select.cpp +++ /dev/null @@ -1,181 +0,0 @@ -#include "cpprx/rx.hpp" -namespace rx=rxcpp; - -#include "catch.hpp" - -SCENARIO("select throws", "[select][map][operators]"){ - GIVEN("select"){ - WHEN("subscribed to onnext that throws"){ - THEN("the exception is not supressed"){ - auto next_throws = [](int){ - throw std::runtime_error("onnext throws"); }; - REQUIRE_THROWS(from(rx::Return(1)) - .select([](int v){return v;}) - .subscribe(next_throws)); - } - } - - WHEN("subscribed to throw operator"){ - THEN("the exception is not supressed"){ - REQUIRE_THROWS(from(rx::Throw(std::runtime_error("throw operator"))) - .select([](int v){return v;}) - .subscribe([](int){}, [](){}, [](std::exception_ptr){ throw std::runtime_error("onerror throws"); })); - } - } - - WHEN("subscribed to oncompleted that throws"){ - THEN("the exception is not supressed"){ - REQUIRE_THROWS(from(rx::Empty()) - .select([](int v){return v;}) - .subscribe([](int){}, [](){ throw std::runtime_error("oncompleted throws"); }, [](std::exception_ptr){})); - } - } - } -} - -SCENARIO("select should throw", "[select][map][operators][hide]"){ - GIVEN("select"){ - WHEN("subscribe throws"){ - THEN("the exception is not supressed"){ - // not yet sure why this fails - auto subscribe_throws = [](std::shared_ptr> observer) -> rxcpp::Disposable { - throw std::runtime_error("subscribe throws"); }; - REQUIRE_THROWS(from(rx::CreateObservable(subscribe_throws)) - .select([](int v){return v;}) - .subscribe([](int){})); - } - } - } -} - -SCENARIO("select stops on completion", "[select][map][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(180, 1), - m::OnNext(210, 2), - m::OnNext(240, 3), - m::OnNext(290, 4), - m::OnNext(350, 5), - m::OnCompleted(400), - m::OnNext(410, -1), - m::OnCompleted(420), - m::OnError(430, std::exception()) - }; - return m::ToVector(messages); - }() - ); - - WHEN("mapped to ints that are one larger"){ - - auto res = scheduler->Start( - [xs, &invoked]() { - return rx::observable(rx::from(xs) - .select([&invoked](int x) { - invoked++; - return x + 1; - })); - } - ); - - THEN("the output only contains primes"){ - m::RecordedT items[] = { - m::OnNext(210, 3), - m::OnNext(240, 4), - m::OnNext(290, 5), - m::OnNext(350, 6), - m::OnCompleted(400), - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(200, 400) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("where was called until completed"){ - REQUIRE(4 == invoked); - } - } - } -} - -SCENARIO("select stops on disposal", "[select][map][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(100, 1), - m::OnNext(200, 2), - m::OnNext(500, 3), - m::OnNext(600, 4) - }; - return m::ToVector(messages); - }() - ); - - auto res = scheduler->CreateObserver(); - - WHEN("the ints are identity mapped"){ - - rx::SerialDisposable d; - - d.Set(observable(from(xs) - .select([&](int x) { - invoked++; - if (scheduler->Clock() > 400) { - d.Dispose(); - } - return x; - })) - ->Subscribe(observer(res)) - ); - - scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&](rx::Scheduler::shared) { - d.Dispose(); return rx::Disposable::Empty();}); - - scheduler->Start(); - - THEN("the output only contains values that arrived before disposal"){ - m::RecordedT items[] = { - m::OnNext(100, 1), - m::OnNext(200, 2) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(0, 500) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("select was called until disposed"){ - REQUIRE(3 == invoked); - } - } - } -} diff --git a/Rx/CPP/test/operators/SelectMany.cpp b/Rx/CPP/test/operators/SelectMany.cpp deleted file mode 100644 index 9daef6c..0000000 --- a/Rx/CPP/test/operators/SelectMany.cpp +++ /dev/null @@ -1,279 +0,0 @@ -#include "cpprx/rx.hpp" -namespace rx=rxcpp; - -#include "catch.hpp" - -SCENARIO("select_many completes", "[select_many][map][operators]"){ - GIVEN("two cold observables. one of ints. one of strings."){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - typedef rx::TestScheduler::Messages ms; - - long invoked = 0; - - auto xs = scheduler->CreateColdObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(100, 4), - m::OnNext(200, 2), - m::OnNext(300, 3), - m::OnNext(400, 1), - m::OnCompleted(500) - }; - return m::ToVector(messages); - }() - ); - - auto ys = scheduler->CreateColdObservable( - []() { - ms::RecordedT messages[] = { - ms::OnNext(50, "foo"), - ms::OnNext(100, "bar"), - ms::OnNext(150, "baz"), - ms::OnNext(200, "qux"), - ms::OnCompleted(250) - }; - return ms::ToVector(messages); - }() - ); - - WHEN("each int is mapped to the strings"){ - - auto res = scheduler->Start( - [&]() { - return observable(from(xs) - .select_many([&](int){return ys;})); - } - ); - - THEN("the output contains strings repeated for each int"){ - ms::RecordedT items[] = { - ms::OnNext(350, "foo"), - ms::OnNext(400, "bar"), - ms::OnNext(450, "foo"), - ms::OnNext(450, "baz"), - ms::OnNext(500, "bar"), - ms::OnNext(500, "qux"), - ms::OnNext(550, "baz"), - ms::OnNext(550, "foo"), - ms::OnNext(600, "bar"), - ms::OnNext(600, "qux"), - ms::OnNext(650, "baz"), - ms::OnNext(650, "foo"), - ms::OnNext(700, "qux"), - ms::OnNext(700, "bar"), - ms::OnNext(750, "baz"), - ms::OnNext(800, "qux"), - ms::OnCompleted(850) - }; - auto required = ms::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the ints"){ - rx::Subscription items[] = { - m::Subscribe(200, 700) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("there were four subscription and unsubscription to the strings"){ - rx::Subscription items[] = { - ms::Subscribe(300, 550), - ms::Subscribe(400, 650), - ms::Subscribe(500, 750), - ms::Subscribe(600, 850) - }; - auto required = m::ToVector(items); - auto actual = ys->Subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("select_many source never ends", "[select_many][map][operators]"){ - GIVEN("two cold observables. one of ints. one of strings."){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - typedef rx::TestScheduler::Messages ms; - - long invoked = 0; - - auto xs = scheduler->CreateColdObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(100, 4), - m::OnNext(200, 2), - m::OnNext(300, 3), - m::OnNext(400, 1), - m::OnNext(500, 5), - m::OnNext(700, 0) - }; - return m::ToVector(messages); - }() - ); - - auto ys = scheduler->CreateColdObservable( - []() { - ms::RecordedT messages[] = { - ms::OnNext(55, "foo"), - ms::OnNext(104, "bar"), - ms::OnNext(153, "baz"), - ms::OnNext(202, "qux"), - ms::OnCompleted(251) - }; - return ms::ToVector(messages); - }() - ); - - WHEN("each int is mapped to the strings"){ - - auto res = scheduler->Start( - [&]() { - return observable(from(xs) - .select_many([&](int){return ys;})); - } - ); - - THEN("the output contains strings repeated for each int"){ - ms::RecordedT items[] = { - ms::OnNext(355, "foo"), - ms::OnNext(404, "bar"), - ms::OnNext(453, "baz"), - ms::OnNext(455, "foo"), - ms::OnNext(502, "qux"), - ms::OnNext(504, "bar"), - ms::OnNext(553, "baz"), - ms::OnNext(555, "foo"), - ms::OnNext(602, "qux"), - ms::OnNext(604, "bar"), - ms::OnNext(653, "baz"), - ms::OnNext(655, "foo"), - ms::OnNext(702, "qux"), - ms::OnNext(704, "bar"), - ms::OnNext(753, "baz"), - ms::OnNext(755, "foo"), - ms::OnNext(802, "qux"), - ms::OnNext(804, "bar"), - ms::OnNext(853, "baz"), - ms::OnNext(902, "qux"), - ms::OnNext(955, "foo") - }; - auto required = ms::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the ints"){ - rx::Subscription items[] = { - m::Subscribe(200, 1000) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("there were four subscription and unsubscription to the strings"){ - rx::Subscription items[] = { - ms::Subscribe(300, 551), - ms::Subscribe(400, 651), - ms::Subscribe(500, 751), - ms::Subscribe(600, 851), - ms::Subscribe(700, 951), - ms::Subscribe(900, 1000) - }; - auto required = m::ToVector(items); - auto actual = ys->Subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("select_many inner error", "[select_many][map][operators]"){ - GIVEN("two cold observables. one of ints. one of strings."){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - typedef rx::TestScheduler::Messages ms; - - long invoked = 0; - - auto xs = scheduler->CreateColdObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(100, 4), - m::OnNext(200, 2), - m::OnNext(300, 3), - m::OnNext(400, 1), - m::OnCompleted(500) - }; - return m::ToVector(messages); - }() - ); - - auto ys = scheduler->CreateColdObservable( - []() { - ms::RecordedT messages[] = { - ms::OnNext(55, "foo"), - ms::OnNext(104, "bar"), - ms::OnNext(153, "baz"), - ms::OnNext(202, "qux"), - ms::OnError(301, std::exception()) - }; - return ms::ToVector(messages); - }() - ); - - WHEN("each int is mapped to the strings"){ - - auto res = scheduler->Start( - [&]() { - return observable(from(xs) - .select_many([&](int){return ys;})); - } - ); - - THEN("the output contains strings repeated for each int"){ - ms::RecordedT items[] = { - ms::OnNext(355, "foo"), - ms::OnNext(404, "bar"), - ms::OnNext(453, "baz"), - ms::OnNext(455, "foo"), - ms::OnNext(502, "qux"), - ms::OnNext(504, "bar"), - ms::OnNext(553, "baz"), - ms::OnNext(555, "foo"), - ms::OnError(601, std::exception()) - }; - auto required = ms::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the ints"){ - rx::Subscription items[] = { - m::Subscribe(200, 601) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("there were four subscription and unsubscription to the strings"){ - rx::Subscription items[] = { - ms::Subscribe(300, 601), - ms::Subscribe(400, 601), - ms::Subscribe(500, 601), - ms::Subscribe(600, 601) - }; - auto required = ms::ToVector(items); - auto actual = ys->Subscriptions(); - REQUIRE(required == actual); - } - } - } -} diff --git a/Rx/CPP/test/operators/Where.cpp b/Rx/CPP/test/operators/Where.cpp deleted file mode 100644 index ddfbb3a..0000000 --- a/Rx/CPP/test/operators/Where.cpp +++ /dev/null @@ -1,389 +0,0 @@ -#include "cpprx/rx.hpp" -namespace rx=rxcpp; - -#include "catch.hpp" - -bool IsPrime(int x) -{ - if (x < 2) return false; - for (int i = 2; i <= x/2; ++i) - { - if (x % i == 0) - return false; - } - return true; -} - -SCENARIO("where stops on completion", "[where][filter][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(110, 1), - m::OnNext(180, 2), - m::OnNext(230, 3), - m::OnNext(270, 4), - m::OnNext(340, 5), - m::OnNext(380, 6), - m::OnNext(390, 7), - m::OnNext(450, 8), - m::OnNext(470, 9), - m::OnNext(560, 10), - m::OnNext(580, 11), - m::OnCompleted(600), - m::OnNext(610, 12), - m::OnError(620, std::exception()), - m::OnCompleted(630) - }; - return m::ToVector(messages); - }() - ); - - WHEN("filtered to ints that are primes"){ - - auto res = scheduler->Start( - [xs, &invoked]() { - return rx::observable(rx::from(xs) - .where([&invoked](int x) { - invoked++; - return IsPrime(x); - })); - } - ); - - THEN("the output only contains primes"){ - m::RecordedT items[] = { - m::OnNext(230, 3), - m::OnNext(340, 5), - m::OnNext(390, 7), - m::OnNext(580, 11), - m::OnCompleted(600) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(200, 600) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("where was called until completed"){ - REQUIRE(9 == invoked); - } - } - } -} - -SCENARIO("where stops on disposal", "[where][filter][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(110, 1), - m::OnNext(180, 2), - m::OnNext(230, 3), - m::OnNext(270, 4), - m::OnNext(340, 5), - m::OnNext(380, 6), - m::OnNext(390, 7), - m::OnNext(450, 8), - m::OnNext(470, 9), - m::OnNext(560, 10), - m::OnNext(580, 11), - m::OnCompleted(600) - }; - return m::ToVector(messages); - }() - ); - - WHEN("filtered to ints that are primes"){ - - auto res = scheduler->Start( - [xs, &invoked]() { - return rx::observable(rx::from(xs) - .where([&invoked](int x) { - invoked++; - return IsPrime(x); - })); - }, - 400 - ); - - THEN("the output only contains primes that arrived before disposal"){ - m::RecordedT items[] = { - m::OnNext(230, 3), - m::OnNext(340, 5), - m::OnNext(390, 7) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(200, 400) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("where was called until disposed"){ - REQUIRE(5 == invoked); - } - } - } -} - -SCENARIO("where stops on error", "[where][filter][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - std::exception ex; - - auto xs = scheduler->CreateHotObservable( - [ex]() { - m::RecordedT messages[] = { - m::OnNext(110, 1), - m::OnNext(180, 2), - m::OnNext(230, 3), - m::OnNext(270, 4), - m::OnNext(340, 5), - m::OnNext(380, 6), - m::OnNext(390, 7), - m::OnNext(450, 8), - m::OnNext(470, 9), - m::OnNext(560, 10), - m::OnNext(580, 11), - m::OnError(600, ex), - m::OnNext(610, 12), - m::OnError(620, std::exception()), - m::OnCompleted(630) - }; - return m::ToVector(messages); - }() - ); - - WHEN("filtered to ints that are primes"){ - - auto res = scheduler->Start( - [xs, &invoked]() { - return rx::observable(rx::from(xs) - .where([&invoked](int x) { - invoked++; - return IsPrime(x); - })); - } - ); - - THEN("the output only contains primes"){ - m::RecordedT items[] = { - m::OnNext(230, 3), - m::OnNext(340, 5), - m::OnNext(390, 7), - m::OnNext(580, 11), - m::OnError(600, ex), - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(200, 600) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("where was called until error"){ - REQUIRE(9 == invoked); - } - } - } -} - -SCENARIO("where stops on throw from predicate", "[where][filter][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - std::exception ex; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(110, 1), - m::OnNext(180, 2), - m::OnNext(230, 3), - m::OnNext(270, 4), - m::OnNext(340, 5), - m::OnNext(380, 6), - m::OnNext(390, 7), - m::OnNext(450, 8), - m::OnNext(470, 9), - m::OnNext(560, 10), - m::OnNext(580, 11), - m::OnCompleted(600), - m::OnNext(610, 12), - m::OnError(620, std::exception()), - m::OnCompleted(630) - }; - return m::ToVector(messages); - }() - ); - - WHEN("filtered to ints that are primes"){ - - auto res = scheduler->Start( - [ex, xs, &invoked]() { - return rx::observable(rx::from(xs) - .where([ex, &invoked](int x) { - invoked++; - if (x > 5) { - throw ex; - } - return IsPrime(x); - })); - } - ); - - THEN("the output only contains primes"){ - m::RecordedT items[] = { - m::OnNext(230, 3), - m::OnNext(340, 5), - m::OnError(380, ex) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(200, 380) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("where was called until error"){ - REQUIRE(4 == invoked); - } - } - } -} - -SCENARIO("where stops on dispose from predicate", "[where][filter][operators]"){ - GIVEN("a test hot observable of ints"){ - auto scheduler = std::make_shared(); - typedef rx::TestScheduler::Messages m; - - long invoked = 0; - - auto xs = scheduler->CreateHotObservable( - []() { - m::RecordedT messages[] = { - m::OnNext(110, 1), - m::OnNext(180, 2), - m::OnNext(230, 3), - m::OnNext(270, 4), - m::OnNext(340, 5), - m::OnNext(380, 6), - m::OnNext(390, 7), - m::OnNext(450, 8), - m::OnNext(470, 9), - m::OnNext(560, 10), - m::OnNext(580, 11), - m::OnCompleted(600), - m::OnNext(610, 12), - m::OnError(620, std::exception()), - m::OnCompleted(630) - }; - return m::ToVector(messages); - }() - ); - - auto res = scheduler->CreateObserver(); - - rx::SerialDisposable d; - std::shared_ptr> ys; - - WHEN("filtered to ints that are primes"){ - - scheduler->ScheduleAbsolute(rx::TestScheduler::Created, - [&invoked, &d, &ys, &xs](rx::Scheduler::shared) { - ys = rx::observable(rx::from(xs) - .where([&invoked, &d](int x) { - invoked++; - if (x == 8) - d.Dispose(); - return IsPrime(x); - })); - return rx::Disposable::Empty(); - }); - - scheduler->ScheduleAbsolute(rx::TestScheduler::Subscribed, [&d, &ys, &res](rx::Scheduler::shared) { - d.Set(ys->Subscribe(res)); - return rx::Disposable::Empty(); - }); - - scheduler->ScheduleAbsolute(rx::TestScheduler::Disposed, [&d](rx::Scheduler::shared) { - d.Dispose(); - return rx::Disposable::Empty(); - }); - - scheduler->Start(); - - THEN("the output only contains primes"){ - m::RecordedT items[] = { - m::OnNext(230, 3), - m::OnNext(340, 5), - m::OnNext(390, 7) - }; - auto required = m::ToVector(items); - auto actual = res->Messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription"){ - rx::Subscription items[] = { - m::Subscribe(200, 450) - }; - auto required = m::ToVector(items); - auto actual = xs->Subscriptions(); - REQUIRE(required == actual); - } - - THEN("where was called until disposed"){ - REQUIRE(6 == invoked); - } - } - } -} - diff --git a/Rx/CPP/test/test.cpp b/Rx/CPP/test/test.cpp deleted file mode 100644 index 0c7c351..0000000 --- a/Rx/CPP/test/test.cpp +++ /dev/null @@ -1,2 +0,0 @@ -#define CATCH_CONFIG_MAIN -#include "catch.hpp" diff --git a/Rx/CPP/testbench/data.txt b/Rx/CPP/testbench/data.txt deleted file mode 100644 index b16aea6..0000000 --- a/Rx/CPP/testbench/data.txt +++ /dev/null @@ -1,655 +0,0 @@ -{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22437888.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.9785421875}} -{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26136576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.956228125}} -{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22503424.0, 'privatemem': 25968640.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 71.741975}} -{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26177536.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.189240625}} -{'var': [('concurrency', 1), ('args', '-test async-gated')], 'result': {'workingset': 22323200.0, 'privatemem': 25808896.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 71.7897296875}} -{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14917632.0, 'privatemem': 20385792.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.734965625}} -{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15060992.0, 'privatemem': 20545536.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.028878125}} -{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 15052800.0, 'privatemem': 20529152.0, 'nonpaged': 26768.0, 'virtualmem': 577224704.0, 'time': 45.5304375}} -{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14934016.0, 'privatemem': 20406272.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.898271875}} -{'var': [('concurrency', 1), ('args', '-test ums-gated')], 'result': {'workingset': 14991360.0, 'privatemem': 20447232.0, 'nonpaged': 26784.0, 'virtualmem': 577224704.0, 'time': 45.425371875}} -{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 32.748084375}} -{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26202112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.5510765625}} -{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22556672.0, 'privatemem': 26021888.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.0404453125}} -{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26038272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 34.0872890625}} -{'var': [('concurrency', 2), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25976832.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 33.026740625}} -{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15093760.0, 'privatemem': 21082112.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 23.0056984375}} -{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20918272.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2537171875}} -{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15208448.0, 'privatemem': 20905984.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.2316484375}} -{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15192064.0, 'privatemem': 20910080.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.259509375}} -{'var': [('concurrency', 2), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 20979712.0, 'nonpaged': 27264.0, 'virtualmem': 585613312.0, 'time': 23.3385359375}} -{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25952256.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2717265625}} -{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22667264.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.2175609375}} -{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26042368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.07530625}} -{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26013696.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.281884375}} -{'var': [('concurrency', 3), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26185728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 20.05386875}} -{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15245312.0, 'privatemem': 21233664.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.3586671875}} -{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15310848.0, 'privatemem': 21250048.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.70775625}} -{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15347712.0, 'privatemem': 21254144.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.6456703125}} -{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15273984.0, 'privatemem': 21180416.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.303421875}} -{'var': [('concurrency', 3), ('args', '-test ums-gated')], 'result': {'workingset': 15335424.0, 'privatemem': 21299200.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 15.4817796875}} -{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 25980928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7404328125}} -{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22482944.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2058328125}} -{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22646784.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 17.3264390625}} -{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.233396875}} -{'var': [('concurrency', 4), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.4778453125}} -{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15200256.0, 'privatemem': 21196800.0, 'nonpaged': 27744.0, 'virtualmem': 594001920.0, 'time': 12.3187859375}} -{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15474688.0, 'privatemem': 21725184.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 11.6904421875}} -{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15384576.0, 'privatemem': 21630976.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.795390625}} -{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15364096.0, 'privatemem': 21606400.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.5224484375}} -{'var': [('concurrency', 4), ('args', '-test ums-gated')], 'result': {'workingset': 15343616.0, 'privatemem': 21590016.0, 'nonpaged': 28224.0, 'virtualmem': 602390528.0, 'time': 10.4604203125}} -{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22536192.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.291790625}} -{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22753280.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8192703125}} -{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25919488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1479078125}} -{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22728704.0, 'privatemem': 26058752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7772765625}} -{'var': [('concurrency', 5), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4325453125}} -{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15458304.0, 'privatemem': 21950464.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 11.653565625}} -{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15622144.0, 'privatemem': 22114304.0, 'nonpaged': 28688.0, 'virtualmem': 610779136.0, 'time': 11.60025}} -{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15491072.0, 'privatemem': 21975040.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 15.956359375}} -{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15429632.0, 'privatemem': 21938176.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 16.7639015625}} -{'var': [('concurrency', 5), ('args', '-test ums-gated')], 'result': {'workingset': 15560704.0, 'privatemem': 22102016.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 12.432678125}} -{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26091520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.482378125}} -{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22724608.0, 'privatemem': 26005504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.6995578125}} -{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22601728.0, 'privatemem': 25972736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7111109375}} -{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22675456.0, 'privatemem': 26017792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.24071875}} -{'var': [('concurrency', 6), ('args', '-test async-gated')], 'result': {'workingset': 22822912.0, 'privatemem': 26206208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1442453125}} -{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15446016.0, 'privatemem': 22118400.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.3196953125}} -{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15351808.0, 'privatemem': 21860352.0, 'nonpaged': 28704.0, 'virtualmem': 610779136.0, 'time': 13.8507890625}} -{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15536128.0, 'privatemem': 22384640.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.411578125}} -{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15728640.0, 'privatemem': 22585344.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 11.3764765625}} -{'var': [('concurrency', 6), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22331392.0, 'nonpaged': 28944.0, 'virtualmem': 614973440.0, 'time': 11.253040625}} -{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22650880.0, 'privatemem': 25956352.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.1586765625}} -{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22700032.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2853515625}} -{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9393859375}} -{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22597632.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.95501875}} -{'var': [('concurrency', 7), ('args', '-test async-gated')], 'result': {'workingset': 22794240.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.9703578125}} -{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15720448.0, 'privatemem': 22822912.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.88916875}} -{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15872000.0, 'privatemem': 22978560.0, 'nonpaged': 29648.0, 'virtualmem': 627556352.0, 'time': 9.7966875}} -{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15642624.0, 'privatemem': 22474752.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.072915625}} -{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15605760.0, 'privatemem': 22548480.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.3262265625}} -{'var': [('concurrency', 7), ('args', '-test ums-gated')], 'result': {'workingset': 15503360.0, 'privatemem': 22335488.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.3073703125}} -{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26075136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7767140625}} -{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22683648.0, 'privatemem': 26046464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.6023046875}} -{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22581248.0, 'privatemem': 25968640.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.590659375}} -{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26128384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.797509375}} -{'var': [('concurrency', 8), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26001408.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.114903125}} -{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15843328.0, 'privatemem': 23093248.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.8031640625}} -{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15695872.0, 'privatemem': 22933504.0, 'nonpaged': 29904.0, 'virtualmem': 631750656.0, 'time': 10.78183125}} -{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15626240.0, 'privatemem': 22466560.0, 'nonpaged': 29184.0, 'virtualmem': 619167744.0, 'time': 10.79186875}} -{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15998976.0, 'privatemem': 23089152.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.6507984375}} -{'var': [('concurrency', 8), ('args', '-test ums-gated')], 'result': {'workingset': 15769600.0, 'privatemem': 22892544.0, 'nonpaged': 29664.0, 'virtualmem': 627556352.0, 'time': 10.7464046875}} -{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26107904.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5812421875}} -{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26030080.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.8055078125}} -{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 23019520.0, 'privatemem': 26374144.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.661046875}} -{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22810624.0, 'privatemem': 26165248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8447890625}} -{'var': [('concurrency', 10), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26157056.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7037859375}} -{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15937536.0, 'privatemem': 23482368.0, 'nonpaged': 30384.0, 'virtualmem': 640139264.0, 'time': 9.9560078125}} -{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22953984.0, 'nonpaged': 29888.0, 'virtualmem': 631750656.0, 'time': 9.9779875}} -{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15806464.0, 'privatemem': 23216128.0, 'nonpaged': 30144.0, 'virtualmem': 635944960.0, 'time': 10.0446703125}} -{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15765504.0, 'privatemem': 23171072.0, 'nonpaged': 30128.0, 'virtualmem': 635944960.0, 'time': 9.8954875}} -{'var': [('concurrency', 10), ('args', '-test ums-gated')], 'result': {'workingset': 15732736.0, 'privatemem': 22679552.0, 'nonpaged': 29424.0, 'virtualmem': 623362048.0, 'time': 10.1007609375}} -{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4936453125}} -{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22732800.0, 'privatemem': 26148864.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.54201875}} -{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 25964544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8461453125}} -{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22749184.0, 'privatemem': 26103808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5201171875}} -{'var': [('concurrency', 12), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26173440.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.7564125}} -{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16015360.0, 'privatemem': 23687168.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.308821875}} -{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15978496.0, 'privatemem': 23896064.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3545609375}} -{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16105472.0, 'privatemem': 23773184.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.39604375}} -{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 16003072.0, 'privatemem': 23670784.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 11.3077953125}} -{'var': [('concurrency', 12), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23347200.0, 'nonpaged': 30272.0, 'virtualmem': 640139264.0, 'time': 11.2470921875}} -{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22630400.0, 'privatemem': 26017792.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.5840734375}} -{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22843392.0, 'privatemem': 26238976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.7056515625}} -{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22765568.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.4621296875}} -{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22626304.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.7261640625}} -{'var': [('concurrency', 14), ('args', '-test async-gated')], 'result': {'workingset': 22659072.0, 'privatemem': 26132480.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.43949375}} -{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24227840.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 10.1509875}} -{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15835136.0, 'privatemem': 23486464.0, 'nonpaged': 30512.0, 'virtualmem': 644333568.0, 'time': 10.4571375}} -{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15953920.0, 'privatemem': 23937024.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.21300625}} -{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 16056320.0, 'privatemem': 24068096.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 10.3364984375}} -{'var': [('concurrency', 14), ('args', '-test ums-gated')], 'result': {'workingset': 15851520.0, 'privatemem': 23621632.0, 'nonpaged': 30752.0, 'virtualmem': 648527872.0, 'time': 10.205690625}} -{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26152960.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4346625}} -{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22941696.0, 'privatemem': 26288128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.588709375}} -{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22573056.0, 'privatemem': 25997312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.383815625}} -{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22818816.0, 'privatemem': 26148864.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.60400625}} -{'var': [('concurrency', 16), ('args', '-test async-gated')], 'result': {'workingset': 22716416.0, 'privatemem': 26120192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3768921875}} -{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16101376.0, 'privatemem': 24428544.0, 'nonpaged': 31712.0, 'virtualmem': 665305088.0, 'time': 9.846940625}} -{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16089088.0, 'privatemem': 24199168.0, 'nonpaged': 31232.0, 'virtualmem': 656916480.0, 'time': 11.1524609375}} -{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16199680.0, 'privatemem': 24178688.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 9.9980328125}} -{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16023552.0, 'privatemem': 23977984.0, 'nonpaged': 30992.0, 'virtualmem': 652722176.0, 'time': 11.2873078125}} -{'var': [('concurrency', 16), ('args', '-test ums-gated')], 'result': {'workingset': 16134144.0, 'privatemem': 24387584.0, 'nonpaged': 31472.0, 'virtualmem': 661110784.0, 'time': 9.934396875}} -{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22781952.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4010015625}} -{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22585344.0, 'privatemem': 25985024.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2167890625}} -{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22740992.0, 'privatemem': 26152960.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.4800796875}} -{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26050560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.449178125}} -{'var': [('concurrency', 20), ('args', '-test async-gated')], 'result': {'workingset': 22671360.0, 'privatemem': 26058752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2931078125}} -{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16310272.0, 'privatemem': 25399296.0, 'nonpaged': 32912.0, 'virtualmem': 686276608.0, 'time': 10.06823125}} -{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16154624.0, 'privatemem': 24883200.0, 'nonpaged': 32432.0, 'virtualmem': 677888000.0, 'time': 10.0306984375}} -{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16171008.0, 'privatemem': 25038848.0, 'nonpaged': 32672.0, 'virtualmem': 682082304.0, 'time': 10.06961875}} -{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16216064.0, 'privatemem': 24817664.0, 'nonpaged': 32192.0, 'virtualmem': 673693696.0, 'time': 10.0746796875}} -{'var': [('concurrency', 20), ('args', '-test ums-gated')], 'result': {'workingset': 16375808.0, 'privatemem': 25542656.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 10.037271875}} -{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 25985024.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4086859375}} -{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22634496.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3663890625}} -{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26034176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3019828125}} -{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22786048.0, 'privatemem': 26144768.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.389559375}} -{'var': [('concurrency', 24), ('args', '-test async-gated')], 'result': {'workingset': 22593536.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2155328125}} -{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16252928.0, 'privatemem': 25710592.0, 'nonpaged': 33632.0, 'virtualmem': 698859520.0, 'time': 9.93735}} -{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16265216.0, 'privatemem': 25427968.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.9944796875}} -{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16236544.0, 'privatemem': 25595904.0, 'nonpaged': 33392.0, 'virtualmem': 694665216.0, 'time': 9.94461875}} -{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16257024.0, 'privatemem': 25403392.0, 'nonpaged': 33152.0, 'virtualmem': 690470912.0, 'time': 9.94913125}} -{'var': [('concurrency', 24), ('args', '-test ums-gated')], 'result': {'workingset': 16424960.0, 'privatemem': 26009600.0, 'nonpaged': 33872.0, 'virtualmem': 703053824.0, 'time': 9.9931234375}} -{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26169344.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.376209375}} -{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22528000.0, 'privatemem': 25866240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2378046875}} -{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22761472.0, 'privatemem': 26128384.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.225084375}} -{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22663168.0, 'privatemem': 26038272.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.23915625}} -{'var': [('concurrency', 28), ('args', '-test async-gated')], 'result': {'workingset': 22831104.0, 'privatemem': 26140672.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 13.35693125}} -{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16650240.0, 'privatemem': 26861568.0, 'nonpaged': 34832.0, 'virtualmem': 719831040.0, 'time': 9.7327859375}} -{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16547840.0, 'privatemem': 26378240.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.775103125}} -{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16654336.0, 'privatemem': 26513408.0, 'nonpaged': 34472.0, 'virtualmem': 713539584.0, 'time': 9.8092875}} -{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16445440.0, 'privatemem': 26304512.0, 'nonpaged': 34352.0, 'virtualmem': 711442432.0, 'time': 9.834784375}} -{'var': [('concurrency', 28), ('args', '-test ums-gated')], 'result': {'workingset': 16510976.0, 'privatemem': 26243072.0, 'nonpaged': 34112.0, 'virtualmem': 707248128.0, 'time': 9.9615171875}} -{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22589440.0, 'privatemem': 26005504.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.234246875}} -{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22814720.0, 'privatemem': 26140672.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1942140625}} -{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26079232.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3161734375}} -{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22708224.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2072671875}} -{'var': [('concurrency', 32), ('args', '-test async-gated')], 'result': {'workingset': 22691840.0, 'privatemem': 26120192.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2228828125}} -{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16568320.0, 'privatemem': 27033600.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8727921875}} -{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16764928.0, 'privatemem': 27238400.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8168890625}} -{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16842752.0, 'privatemem': 27193344.0, 'nonpaged': 35192.0, 'virtualmem': 726122496.0, 'time': 9.8725515625}} -{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16732160.0, 'privatemem': 27230208.0, 'nonpaged': 35312.0, 'virtualmem': 728219648.0, 'time': 9.8796578125}} -{'var': [('concurrency', 32), ('args', '-test ums-gated')], 'result': {'workingset': 16576512.0, 'privatemem': 26882048.0, 'nonpaged': 35072.0, 'virtualmem': 724025344.0, 'time': 9.851103125}} -{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22679552.0, 'privatemem': 25993216.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.183775}} -{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1523140625}} -{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22642688.0, 'privatemem': 26009600.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2646}} -{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22609920.0, 'privatemem': 26025984.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.190975}} -{'var': [('concurrency', 40), ('args', '-test async-gated')], 'result': {'workingset': 22806528.0, 'privatemem': 26173440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.290859375}} -{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17313792.0, 'privatemem': 29270016.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 9.8081125}} -{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17297408.0, 'privatemem': 29560832.0, 'nonpaged': 38672.0, 'virtualmem': 786939904.0, 'time': 9.803896875}} -{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17514496.0, 'privatemem': 29667328.0, 'nonpaged': 38552.0, 'virtualmem': 784842752.0, 'time': 10.44371875}} -{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17350656.0, 'privatemem': 29356032.0, 'nonpaged': 38312.0, 'virtualmem': 780648448.0, 'time': 10.5586140625}} -{'var': [('concurrency', 40), ('args', '-test ums-gated')], 'result': {'workingset': 17219584.0, 'privatemem': 29265920.0, 'nonpaged': 38072.0, 'virtualmem': 776454144.0, 'time': 11.02230625}} -{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29392896.0, 'privatemem': 32837632.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.5534375}} -{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32817152.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.04296875}} -{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29323264.0, 'privatemem': 32690176.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5768078125}} -{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 29327360.0, 'privatemem': 32718848.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1712328125}} -{'var': [('concurrency', 48), ('args', '-test async-gated')], 'result': {'workingset': 22704128.0, 'privatemem': 26030080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.193025}} -{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17764352.0, 'privatemem': 30863360.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7636984375}} -{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17707008.0, 'privatemem': 30818304.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.7707}} -{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17625088.0, 'privatemem': 30760960.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.812396875}} -{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17649664.0, 'privatemem': 30711808.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 10.313584375}} -{'var': [('concurrency', 48), ('args', '-test ums-gated')], 'result': {'workingset': 17674240.0, 'privatemem': 30810112.0, 'nonpaged': 40232.0, 'virtualmem': 814202880.0, 'time': 9.8304125}} -{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1279546875}} -{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1256796875}} -{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29585408.0, 'privatemem': 32956416.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.14424375}} -{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29421568.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1787703125}} -{'var': [('concurrency', 56), ('args', '-test async-gated')], 'result': {'workingset': 29347840.0, 'privatemem': 32718848.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121146875}} -{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17829888.0, 'privatemem': 32083968.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7840515625}} -{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17981440.0, 'privatemem': 32190464.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.774884375}} -{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17907712.0, 'privatemem': 32178176.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.7712421875}} -{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 17809408.0, 'privatemem': 32092160.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.883371875}} -{'var': [('concurrency', 56), ('args', '-test ums-gated')], 'result': {'workingset': 18104320.0, 'privatemem': 32366592.0, 'nonpaged': 42152.0, 'virtualmem': 847757312.0, 'time': 9.8319875}} -{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29380608.0, 'privatemem': 32731136.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.139365625}} -{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29401088.0, 'privatemem': 32792576.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1221734375}} -{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29298688.0, 'privatemem': 32735232.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3343921875}} -{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29564928.0, 'privatemem': 32948224.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.144190625}} -{'var': [('concurrency', 64), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 32894976.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.147003125}} -{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18358272.0, 'privatemem': 34308096.0, 'nonpaged': 45032.0, 'virtualmem': 898088960.0, 'time': 9.80116875}} -{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18325504.0, 'privatemem': 33714176.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.898659375}} -{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18300928.0, 'privatemem': 33689600.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7784}} -{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18210816.0, 'privatemem': 33574912.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.9189640625}} -{'var': [('concurrency', 64), ('args', '-test ums-gated')], 'result': {'workingset': 18202624.0, 'privatemem': 33566720.0, 'nonpaged': 44072.0, 'virtualmem': 881311744.0, 'time': 9.7934265625}} -{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29495296.0, 'privatemem': 32886784.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.111571875}} -{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29429760.0, 'privatemem': 32776192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.199890625}} -{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29442048.0, 'privatemem': 32886784.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.11831875}} -{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29597696.0, 'privatemem': 32931840.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1347890625}} -{'var': [('concurrency', 80), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32739328.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.171440625}} -{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19292160.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7851578125}} -{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19222528.0, 'privatemem': 37990400.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.759603125}} -{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19308544.0, 'privatemem': 38092800.0, 'nonpaged': 49928.0, 'virtualmem': 981975040.0, 'time': 9.73698125}} -{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19214336.0, 'privatemem': 38002688.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7582359375}} -{'var': [('concurrency', 80), ('args', '-test ums-gated')], 'result': {'workingset': 19324928.0, 'privatemem': 38129664.0, 'nonpaged': 49832.0, 'virtualmem': 981975040.0, 'time': 9.7412640625}} -{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29474816.0, 'privatemem': 32837632.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.169203125}} -{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29614080.0, 'privatemem': 32976896.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1191375}} -{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29626368.0, 'privatemem': 32968704.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1113484375}} -{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29511680.0, 'privatemem': 33058816.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.1464140625}} -{'var': [('concurrency', 96), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32747520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1111234375}} -{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 20041728.0, 'privatemem': 41103360.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.7898}} -{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19968000.0, 'privatemem': 41009152.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.855309375}} -{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19824640.0, 'privatemem': 40890368.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9260921875}} -{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19947520.0, 'privatemem': 41054208.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.9416703125}} -{'var': [('concurrency', 96), ('args', '-test ums-gated')], 'result': {'workingset': 19808256.0, 'privatemem': 40882176.0, 'nonpaged': 53672.0, 'virtualmem': 1049083904.0, 'time': 9.8916515625}} -{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29691904.0, 'privatemem': 33034240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.11079375}} -{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29458432.0, 'privatemem': 32755712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1449734375}} -{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29315072.0, 'privatemem': 32628736.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13280625}} -{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1016015625}} -{'var': [('concurrency', 112), ('args', '-test async-gated')], 'result': {'workingset': 29417472.0, 'privatemem': 32735232.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.1100125}} -{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20836352.0, 'privatemem': 44212224.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.02668125}} -{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20934656.0, 'privatemem': 44322816.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.9877078125}} -{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 21037056.0, 'privatemem': 45981696.0, 'nonpaged': 60152.0, 'virtualmem': 1162330112.0, 'time': 9.9358015625}} -{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20824064.0, 'privatemem': 44150784.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 9.98304375}} -{'var': [('concurrency', 112), ('args', '-test ums-gated')], 'result': {'workingset': 20856832.0, 'privatemem': 44257280.0, 'nonpaged': 57512.0, 'virtualmem': 1116192768.0, 'time': 10.009546875}} -{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 33009664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.0923984375}} -{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.163709375}} -{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32849920.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1063703125}} -{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29450240.0, 'privatemem': 32800768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0826171875}} -{'var': [('concurrency', 128), ('args', '-test async-gated')], 'result': {'workingset': 29528064.0, 'privatemem': 32833536.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.086065625}} -{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21835776.0, 'privatemem': 48500736.0, 'nonpaged': 63032.0, 'virtualmem': 1212661760.0, 'time': 10.0842015625}} -{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21663744.0, 'privatemem': 47255552.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.0181609375}} -{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21577728.0, 'privatemem': 47198208.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 10.846165625}} -{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21389312.0, 'privatemem': 46759936.0, 'nonpaged': 61112.0, 'virtualmem': 1179107328.0, 'time': 11.5423390625}} -{'var': [('concurrency', 128), ('args', '-test ums-gated')], 'result': {'workingset': 21254144.0, 'privatemem': 46899200.0, 'nonpaged': 61352.0, 'virtualmem': 1183301632.0, 'time': 11.306240625}} -{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32927744.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.85168125}} -{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 33005568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 14.58709375}} -{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32862208.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5917140625}} -{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32821248.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1530390625}} -{'var': [('concurrency', 160), ('args', '-test async-gated')], 'result': {'workingset': 29405184.0, 'privatemem': 32788480.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08974375}} -{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23420928.0, 'privatemem': 55808000.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2232734375}} -{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23494656.0, 'privatemem': 55554048.0, 'nonpaged': 72392.0, 'virtualmem': 1376239616.0, 'time': 10.3183484375}} -{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23584768.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.3544203125}} -{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23617536.0, 'privatemem': 55844864.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.2523703125}} -{'var': [('concurrency', 160), ('args', '-test ums-gated')], 'result': {'workingset': 23609344.0, 'privatemem': 55885824.0, 'nonpaged': 72872.0, 'virtualmem': 1384628224.0, 'time': 10.154103125}} -{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29544448.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0866078125}} -{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29507584.0, 'privatemem': 32878592.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0993953125}} -{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29483008.0, 'privatemem': 32841728.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.10189375}} -{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29470720.0, 'privatemem': 32874496.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.0977}} -{'var': [('concurrency', 192), ('args', '-test async-gated')], 'result': {'workingset': 29581312.0, 'privatemem': 32894976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.0975171875}} -{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24719360.0, 'privatemem': 61693952.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.415759375}} -{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24862720.0, 'privatemem': 61919232.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2971765625}} -{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24784896.0, 'privatemem': 61628416.0, 'nonpaged': 80552.0, 'virtualmem': 1518845952.0, 'time': 10.34406875}} -{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24969216.0, 'privatemem': 61984768.0, 'nonpaged': 80792.0, 'virtualmem': 1523040256.0, 'time': 10.2925640625}} -{'var': [('concurrency', 192), ('args', '-test ums-gated')], 'result': {'workingset': 24752128.0, 'privatemem': 61415424.0, 'nonpaged': 80312.0, 'virtualmem': 1514651648.0, 'time': 10.284221875}} -{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29650944.0, 'privatemem': 33046528.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.15705625}} -{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29700096.0, 'privatemem': 33017856.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.122590625}} -{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29659136.0, 'privatemem': 33026048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.08970625}} -{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29491200.0, 'privatemem': 32915456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1275171875}} -{'var': [('concurrency', 224), ('args', '-test async-gated')], 'result': {'workingset': 29532160.0, 'privatemem': 32882688.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.14285}} -{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26378240.0, 'privatemem': 67780608.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.4648703125}} -{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26124288.0, 'privatemem': 67293184.0, 'nonpaged': 88112.0, 'virtualmem': 1653063680.0, 'time': 10.5292671875}} -{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26046464.0, 'privatemem': 67276800.0, 'nonpaged': 87992.0, 'virtualmem': 1648869376.0, 'time': 10.491190625}} -{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26034176.0, 'privatemem': 67489792.0, 'nonpaged': 88232.0, 'virtualmem': 1653063680.0, 'time': 10.5243890625}} -{'var': [('concurrency', 224), ('args', '-test ums-gated')], 'result': {'workingset': 26234880.0, 'privatemem': 67649536.0, 'nonpaged': 88352.0, 'virtualmem': 1657257984.0, 'time': 10.5925109375}} -{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29548544.0, 'privatemem': 32944128.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.150478125}} -{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29741056.0, 'privatemem': 33099776.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1190796875}} -{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 33005568.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.178025}} -{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29536256.0, 'privatemem': 32948224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1318578125}} -{'var': [('concurrency', 256), ('args', '-test async-gated')], 'result': {'workingset': 29933568.0, 'privatemem': 33325056.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 13.130896875}} -{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27303936.0, 'privatemem': 73404416.0, 'nonpaged': 96272.0, 'virtualmem': 1795670016.0, 'time': 10.5394765625}} -{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27607040.0, 'privatemem': 73625600.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.565934375}} -{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27287552.0, 'privatemem': 72835072.0, 'nonpaged': 95552.0, 'virtualmem': 1783087104.0, 'time': 10.6236890625}} -{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27480064.0, 'privatemem': 73379840.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.57548125}} -{'var': [('concurrency', 256), ('args', '-test ums-gated')], 'result': {'workingset': 27201536.0, 'privatemem': 73240576.0, 'nonpaged': 96032.0, 'virtualmem': 1791475712.0, 'time': 10.68160625}} -{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29671424.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.175703125}} -{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29827072.0, 'privatemem': 33165312.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1375234375}} -{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29777920.0, 'privatemem': 33116160.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.121140625}} -{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29589504.0, 'privatemem': 32870400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1075078125}} -{'var': [('concurrency', 320), ('args', '-test async-gated')], 'result': {'workingset': 29704192.0, 'privatemem': 33001472.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.150696875}} -{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29577216.0, 'privatemem': 84500480.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.8671703125}} -{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29835264.0, 'privatemem': 84918272.0, 'nonpaged': 111392.0, 'virtualmem': 2059911168.0, 'time': 10.893078125}} -{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29667328.0, 'privatemem': 84197376.0, 'nonpaged': 110672.0, 'virtualmem': 2047328256.0, 'time': 10.899709375}} -{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29663232.0, 'privatemem': 84520960.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.9027828125}} -{'var': [('concurrency', 320), ('args', '-test ums-gated')], 'result': {'workingset': 29720576.0, 'privatemem': 84615168.0, 'nonpaged': 111152.0, 'virtualmem': 2055716864.0, 'time': 10.904421875}} -{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29646848.0, 'privatemem': 32960512.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.132984375}} -{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29839360.0, 'privatemem': 33132544.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.13160625}} -{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29978624.0, 'privatemem': 33378304.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.1281796875}} -{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33095680.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1194140625}} -{'var': [('concurrency', 384), ('args', '-test async-gated')], 'result': {'workingset': 29880320.0, 'privatemem': 33148928.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.140121875}} -{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32329728.0, 'privatemem': 96473088.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.03265625}} -{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32165888.0, 'privatemem': 96047104.0, 'nonpaged': 126272.0, 'virtualmem': 2319958016.0, 'time': 11.1066328125}} -{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32178176.0, 'privatemem': 96284672.0, 'nonpaged': 126512.0, 'virtualmem': 2324152320.0, 'time': 11.0177765625}} -{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32161792.0, 'privatemem': 96284672.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.15135}} -{'var': [('concurrency', 384), ('args', '-test ums-gated')], 'result': {'workingset': 32096256.0, 'privatemem': 96309248.0, 'nonpaged': 126752.0, 'virtualmem': 2328346624.0, 'time': 11.1041015625}} -{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29798400.0, 'privatemem': 33148928.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.127125}} -{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29913088.0, 'privatemem': 33284096.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1395265625}} -{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29921280.0, 'privatemem': 33263616.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.136646875}} -{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29761536.0, 'privatemem': 33140736.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1379828125}} -{'var': [('concurrency', 448), ('args', '-test async-gated')], 'result': {'workingset': 29818880.0, 'privatemem': 33173504.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.7975015625}} -{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34549760.0, 'privatemem': 107462656.0, 'nonpaged': 141632.0, 'virtualmem': 2588393472.0, 'time': 12.9889609375}} -{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34643968.0, 'privatemem': 108085248.0, 'nonpaged': 142352.0, 'virtualmem': 2600976384.0, 'time': 13.0880796875}} -{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34697216.0, 'privatemem': 107810816.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 13.2690765625}} -{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34508800.0, 'privatemem': 107683840.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 12.4901671875}} -{'var': [('concurrency', 448), ('args', '-test ums-gated')], 'result': {'workingset': 34443264.0, 'privatemem': 107638784.0, 'nonpaged': 141872.0, 'virtualmem': 2592587776.0, 'time': 11.23786875}} -{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29847552.0, 'privatemem': 33222656.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.127740625}} -{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29859840.0, 'privatemem': 33206272.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22630625}} -{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29896704.0, 'privatemem': 33259520.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1849640625}} -{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 29884416.0, 'privatemem': 33206272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.13985}} -{'var': [('concurrency', 512), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33333248.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1424328125}} -{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37142528.0, 'privatemem': 119185408.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.397996875}} -{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37056512.0, 'privatemem': 119328768.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.38355}} -{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37068800.0, 'privatemem': 119164928.0, 'nonpaged': 156992.0, 'virtualmem': 2856828928.0, 'time': 11.4034015625}} -{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37187584.0, 'privatemem': 119382016.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.341525}} -{'var': [('concurrency', 512), ('args', '-test ums-gated')], 'result': {'workingset': 37076992.0, 'privatemem': 119296000.0, 'nonpaged': 157232.0, 'virtualmem': 2861023232.0, 'time': 11.373334375}} -{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30105600.0, 'privatemem': 33378304.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.18291875}} -{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30064640.0, 'privatemem': 33406976.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.201753125}} -{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30154752.0, 'privatemem': 33447936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1939015625}} -{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30044160.0, 'privatemem': 33349632.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2285859375}} -{'var': [('concurrency', 640), ('args', '-test async-gated')], 'result': {'workingset': 30068736.0, 'privatemem': 33341440.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1834984375}} -{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47366144.0, 'privatemem': 141705216.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.7742625}} -{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47321088.0, 'privatemem': 141434880.0, 'nonpaged': 187712.0, 'virtualmem': 3393699840.0, 'time': 11.8519890625}} -{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47198208.0, 'privatemem': 141729792.0, 'nonpaged': 188432.0, 'virtualmem': 3406282752.0, 'time': 11.8748625}} -{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47349760.0, 'privatemem': 141578240.0, 'nonpaged': 187952.0, 'virtualmem': 3397894144.0, 'time': 11.80855625}} -{'var': [('concurrency', 640), ('args', '-test ums-gated')], 'result': {'workingset': 47333376.0, 'privatemem': 141635584.0, 'nonpaged': 188192.0, 'virtualmem': 3402088448.0, 'time': 11.8793171875}} -{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30441472.0, 'privatemem': 33677312.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1907140625}} -{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30380032.0, 'privatemem': 33607680.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.224996875}} -{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30326784.0, 'privatemem': 33628160.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.1955234375}} -{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30355456.0, 'privatemem': 33726464.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 13.1947671875}} -{'var': [('concurrency', 768), ('args', '-test async-gated')], 'result': {'workingset': 30322688.0, 'privatemem': 33738752.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2064796875}} -{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52543488.0, 'privatemem': 163958784.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 11.974178125}} -{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52502528.0, 'privatemem': 164315136.0, 'nonpaged': 219512.0, 'virtualmem': 3955736576.0, 'time': 11.9167046875}} -{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52707328.0, 'privatemem': 164122624.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.118128125}} -{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52293632.0, 'privatemem': 163651584.0, 'nonpaged': 218792.0, 'virtualmem': 3943153664.0, 'time': 12.049109375}} -{'var': [('concurrency', 768), ('args', '-test ums-gated')], 'result': {'workingset': 52748288.0, 'privatemem': 163999744.0, 'nonpaged': 219032.0, 'virtualmem': 3947347968.0, 'time': 12.0723515625}} -{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30642176.0, 'privatemem': 33882112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1681703125}} -{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30302208.0, 'privatemem': 33697792.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.1825015625}} -{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30408704.0, 'privatemem': 33726464.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2253203125}} -{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30486528.0, 'privatemem': 33800192.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.250696875}} -{'var': [('concurrency', 896), ('args', '-test async-gated')], 'result': {'workingset': 30560256.0, 'privatemem': 33894400.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.174471875}} -{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58105856.0, 'privatemem': 186347520.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.09041875}} -{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57851904.0, 'privatemem': 186142720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9983140625}} -{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57663488.0, 'privatemem': 185761792.0, 'nonpaged': 249512.0, 'virtualmem': 4480024576.0, 'time': 12.26386875}} -{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 57929728.0, 'privatemem': 186257408.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 11.9970984375}} -{'var': [('concurrency', 896), ('args', '-test ums-gated')], 'result': {'workingset': 58085376.0, 'privatemem': 186654720.0, 'nonpaged': 249752.0, 'virtualmem': 4484218880.0, 'time': 12.0862875}} -{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30867456.0, 'privatemem': 34107392.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2160328125}} -{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 30945280.0, 'privatemem': 34258944.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.2101375}} -{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31059968.0, 'privatemem': 34291712.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3171546875}} -{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31064064.0, 'privatemem': 34279424.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2282890625}} -{'var': [('concurrency', 1024), ('args', '-test async-gated')], 'result': {'workingset': 31006720.0, 'privatemem': 34263040.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.209078125}} -{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63021056.0, 'privatemem': 208171008.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 13.048375}} -{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63369216.0, 'privatemem': 208424960.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.2770109375}} -{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63447040.0, 'privatemem': 208539648.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.228196875}} -{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63488000.0, 'privatemem': 208715776.0, 'nonpaged': 280232.0, 'virtualmem': 5016895488.0, 'time': 12.670853125}} -{'var': [('concurrency', 1024), ('args', '-test ums-gated')], 'result': {'workingset': 63070208.0, 'privatemem': 208207872.0, 'nonpaged': 279992.0, 'virtualmem': 5012701184.0, 'time': 12.4422}} -{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31617024.0, 'privatemem': 34848768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.2811921875}} -{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31719424.0, 'privatemem': 34897920.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22355625}} -{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31494144.0, 'privatemem': 34746368.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.22349375}} -{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31694848.0, 'privatemem': 34947072.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.2325609375}} -{'var': [('concurrency', 1280), ('args', '-test async-gated')], 'result': {'workingset': 31547392.0, 'privatemem': 34807808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.767953125}} -{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 73158656.0, 'privatemem': 252420096.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 15.0598109375}} -{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 65974272.0, 'privatemem': 252903424.0, 'nonpaged': 342152.0, 'virtualmem': 6099025920.0, 'time': 13.8913953125}} -{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66895872.0, 'privatemem': 253501440.0, 'nonpaged': 342632.0, 'virtualmem': 6107414528.0, 'time': 13.2943546875}} -{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 67772416.0, 'privatemem': 252964864.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.7788609375}} -{'var': [('concurrency', 1280), ('args', '-test ums-gated')], 'result': {'workingset': 66498560.0, 'privatemem': 252874752.0, 'nonpaged': 341912.0, 'virtualmem': 6094831616.0, 'time': 12.8031625}} -{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24178688.0, 'privatemem': 27402240.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.357275}} -{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23916544.0, 'privatemem': 27070464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3384296875}} -{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24154112.0, 'privatemem': 27303936.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3860484375}} -{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 24080384.0, 'privatemem': 27303936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.40868125}} -{'var': [('concurrency', 1536), ('args', '-test async-gated')], 'result': {'workingset': 23764992.0, 'privatemem': 26914816.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3454890625}} -{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74870784.0, 'privatemem': 296960000.0, 'nonpaged': 403512.0, 'virtualmem': 7172767744.0, 'time': 13.6358265625}} -{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 84811776.0, 'privatemem': 298262528.0, 'nonpaged': 403832.0, 'virtualmem': 7176962048.0, 'time': 14.18599375}} -{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75407360.0, 'privatemem': 296779776.0, 'nonpaged': 403592.0, 'virtualmem': 7172767744.0, 'time': 13.6721390625}} -{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 75026432.0, 'privatemem': 296505344.0, 'nonpaged': 403112.0, 'virtualmem': 7164379136.0, 'time': 13.3102890625}} -{'var': [('concurrency', 1536), ('args', '-test ums-gated')], 'result': {'workingset': 74461184.0, 'privatemem': 296538112.0, 'nonpaged': 403272.0, 'virtualmem': 7168573440.0, 'time': 14.0042234375}} -{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24694784.0, 'privatemem': 27824128.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.3436484375}} -{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24739840.0, 'privatemem': 27815936.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3563359375}} -{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24772608.0, 'privatemem': 27918336.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4315375}} -{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24756224.0, 'privatemem': 27865088.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.345803125}} -{'var': [('concurrency', 1792), ('args', '-test async-gated')], 'result': {'workingset': 24608768.0, 'privatemem': 27750400.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.402634375}} -{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95748096.0, 'privatemem': 343252992.0, 'nonpaged': 465312.0, 'virtualmem': 8267284480.0, 'time': 14.8233890625}} -{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 96260096.0, 'privatemem': 343367680.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.9048890625}} -{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95764480.0, 'privatemem': 342867968.0, 'nonpaged': 465072.0, 'virtualmem': 8263090176.0, 'time': 14.65851875}} -{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95637504.0, 'privatemem': 342515712.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.7174265625}} -{'var': [('concurrency', 1792), ('args', '-test ums-gated')], 'result': {'workingset': 95924224.0, 'privatemem': 342884352.0, 'nonpaged': 464832.0, 'virtualmem': 8258895872.0, 'time': 14.8882921875}} -{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25047040.0, 'privatemem': 28094464.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3807953125}} -{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24981504.0, 'privatemem': 28151808.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.398909375}} -{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25075712.0, 'privatemem': 28147712.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.359221875}} -{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 25006080.0, 'privatemem': 28098560.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3784}} -{'var': [('concurrency', 2048), ('args', '-test async-gated')], 'result': {'workingset': 24997888.0, 'privatemem': 28069888.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.3560390625}} -{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 105529344.0, 'privatemem': 386404352.0, 'nonpaged': 526512.0, 'virtualmem': 9336832000.0, 'time': 15.17243125}} -{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106209280.0, 'privatemem': 387317760.0, 'nonpaged': 526992.0, 'virtualmem': 9345220608.0, 'time': 15.41375625}} -{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 107094016.0, 'privatemem': 388059136.0, 'nonpaged': 526752.0, 'virtualmem': 9341026304.0, 'time': 15.4270546875}} -{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106483712.0, 'privatemem': 387428352.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.0365046875}} -{'var': [('concurrency', 2048), ('args', '-test ums-gated')], 'result': {'workingset': 106057728.0, 'privatemem': 386617344.0, 'nonpaged': 526272.0, 'virtualmem': 9332637696.0, 'time': 15.11465}} -{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28733440.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4772109375}} -{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29986816.0, 'privatemem': 33038336.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.39680625}} -{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 30007296.0, 'privatemem': 33005568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.43141875}} -{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 25714688.0, 'privatemem': 28782592.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.4375484375}} -{'var': [('concurrency', 2560), ('args', '-test async-gated')], 'result': {'workingset': 29941760.0, 'privatemem': 33050624.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 13.40918125}} -{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 124895232.0, 'privatemem': 473268224.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.8352921875}} -{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125243392.0, 'privatemem': 474202112.0, 'nonpaged': 649152.0, 'virtualmem': 11480121344.0, 'time': 15.9860609375}} -{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 126054400.0, 'privatemem': 474787840.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.8798015625}} -{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 125100032.0, 'privatemem': 473649152.0, 'nonpaged': 648912.0, 'virtualmem': 11475927040.0, 'time': 15.90209375}} -{'var': [('concurrency', 2560), ('args', '-test ums-gated')], 'result': {'workingset': 127406080.0, 'privatemem': 482037760.0, 'nonpaged': 658512.0, 'virtualmem': 11643699200.0, 'time': 16.0772640625}} -{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30760960.0, 'privatemem': 33771520.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.4638640625}} -{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30720000.0, 'privatemem': 33730560.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.4992015625}} -{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30593024.0, 'privatemem': 33632256.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.460190625}} -{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30691328.0, 'privatemem': 33710080.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.584534375}} -{'var': [('concurrency', 3072), ('args', '-test async-gated')], 'result': {'workingset': 30756864.0, 'privatemem': 33738752.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.8325828125}} -{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145821696.0, 'privatemem': 562421760.0, 'nonpaged': 772032.0, 'virtualmem': 13627604992.0, 'time': 18.0121359375}} -{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145391616.0, 'privatemem': 562782208.0, 'nonpaged': 772416.0, 'virtualmem': 13635993600.0, 'time': 16.273371875}} -{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145211392.0, 'privatemem': 561577984.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.684478125}} -{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145367040.0, 'privatemem': 561598464.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.70395}} -{'var': [('concurrency', 3072), ('args', '-test ums-gated')], 'result': {'workingset': 145969152.0, 'privatemem': 562495488.0, 'nonpaged': 771936.0, 'virtualmem': 13627604992.0, 'time': 16.7380234375}} -{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31399936.0, 'privatemem': 34484224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5152703125}} -{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31645696.0, 'privatemem': 34541568.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5179421875}} -{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31395840.0, 'privatemem': 34435072.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.486846875}} -{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34500608.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.5053265625}} -{'var': [('concurrency', 3584), ('args', '-test async-gated')], 'result': {'workingset': 31473664.0, 'privatemem': 34447360.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.506196875}} -{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166944768.0, 'privatemem': 650125312.0, 'nonpaged': 895176.0, 'virtualmem': 15795929088.0, 'time': 17.12616875}} -{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166453248.0, 'privatemem': 650084352.0, 'nonpaged': 895656.0, 'virtualmem': 15804317696.0, 'time': 17.1012453125}} -{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166957056.0, 'privatemem': 650522624.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.041084375}} -{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166461440.0, 'privatemem': 651186176.0, 'nonpaged': 896136.0, 'virtualmem': 15812706304.0, 'time': 17.265559375}} -{'var': [('concurrency', 3584), ('args', '-test ums-gated')], 'result': {'workingset': 166281216.0, 'privatemem': 650743808.0, 'nonpaged': 895416.0, 'virtualmem': 15800123392.0, 'time': 17.20788125}} -{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33193984.0, 'privatemem': 36044800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.543359375}} -{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33120256.0, 'privatemem': 35979264.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5913015625}} -{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35794944.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.5597421875}} -{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 32976896.0, 'privatemem': 35885056.0, 'nonpaged': 25288.0, 'virtualmem': 556580864.0, 'time': 13.561975}} -{'var': [('concurrency', 4096), ('args', '-test async-gated')], 'result': {'workingset': 33013760.0, 'privatemem': 35872768.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.552240625}} -{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188612608.0, 'privatemem': 740990976.0, 'nonpaged': 1019232.0, 'virtualmem': 17964384256.0, 'time': 18.23205}} -{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190369792.0, 'privatemem': 742092800.0, 'nonpaged': 1018176.0, 'virtualmem': 17947607040.0, 'time': 18.1267921875}} -{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 190291968.0, 'privatemem': 751833088.0, 'nonpaged': 1034976.0, 'virtualmem': 18241208320.0, 'time': 18.278765625}} -{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 187871232.0, 'privatemem': 739778560.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 18.356121875}} -{'var': [('concurrency', 4096), ('args', '-test ums-gated')], 'result': {'workingset': 188469248.0, 'privatemem': 739135488.0, 'nonpaged': 1018512.0, 'virtualmem': 17951801344.0, 'time': 17.9174328125}} -{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34922496.0, 'privatemem': 37539840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.705434375}} -{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37617664.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 13.677278125}} -{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 34988032.0, 'privatemem': 37523456.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.64224375}} -{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35012608.0, 'privatemem': 37642240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.65468125}} -{'var': [('concurrency', 5120), ('args', '-test async-gated')], 'result': {'workingset': 35115008.0, 'privatemem': 37711872.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.70276875}} -{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228339712.0, 'privatemem': 915566592.0, 'nonpaged': 1264176.0, 'virtualmem': 22246768640.0, 'time': 19.006409375}} -{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 229093376.0, 'privatemem': 916045824.0, 'nonpaged': 1264296.0, 'virtualmem': 22263349248.0, 'time': 19.33424375}} -{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228802560.0, 'privatemem': 915972096.0, 'nonpaged': 1264184.0, 'virtualmem': 22263349248.0, 'time': 19.201040625}} -{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 228282368.0, 'privatemem': 915853312.0, 'nonpaged': 1263936.0, 'virtualmem': 22242574336.0, 'time': 19.1797125}} -{'var': [('concurrency', 5120), ('args', '-test ums-gated')], 'result': {'workingset': 227971072.0, 'privatemem': 915865600.0, 'nonpaged': 1264896.0, 'virtualmem': 22259351552.0, 'time': 20.5840234375}} -{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36610048.0, 'privatemem': 39178240.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2996234375}} -{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36446208.0, 'privatemem': 39006208.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 15.2134390625}} -{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36413440.0, 'privatemem': 39055360.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.35226875}} -{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36429824.0, 'privatemem': 39075840.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8014796875}} -{'var': [('concurrency', 6144), ('args', '-test async-gated')], 'result': {'workingset': 36474880.0, 'privatemem': 39116800.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.7755546875}} -{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 267964416.0, 'privatemem': 1090080768.0, 'nonpaged': 1509464.0, 'virtualmem': 26549927936.0, 'time': 19.5823140625}} -{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 268500992.0, 'privatemem': 1091354624.0, 'nonpaged': 1509816.0, 'virtualmem': 26554122240.0, 'time': 19.5744}} -{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269398016.0, 'privatemem': 1090744320.0, 'nonpaged': 1509576.0, 'virtualmem': 26549927936.0, 'time': 19.7508015625}} -{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269123584.0, 'privatemem': 1093181440.0, 'nonpaged': 1514664.0, 'virtualmem': 26642202624.0, 'time': 19.75071875}} -{'var': [('concurrency', 6144), ('args', '-test ums-gated')], 'result': {'workingset': 269733888.0, 'privatemem': 1091674112.0, 'nonpaged': 1511384.0, 'virtualmem': 26583482368.0, 'time': 19.5216640625}} -{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36532224.0, 'privatemem': 39153664.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 13.9015625}} -{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 36720640.0, 'privatemem': 39264256.0, 'nonpaged': 25864.0, 'virtualmem': 564969472.0, 'time': 13.90245}} -{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31596544.0, 'privatemem': 34111488.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.8932265625}} -{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34131968.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 13.9260484375}} -{'var': [('concurrency', 7168), ('args', '-test async-gated')], 'result': {'workingset': 31571968.0, 'privatemem': 34066432.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 13.954315625}} -{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 315875328.0, 'privatemem': 1271836672.0, 'nonpaged': 1755264.0, 'virtualmem': 30861475840.0, 'time': 19.696196875}} -{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 312127488.0, 'privatemem': 1268944896.0, 'nonpaged': 1755944.0, 'virtualmem': 30869929984.0, 'time': 19.7884125}} -{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313524224.0, 'privatemem': 1270001664.0, 'nonpaged': 1755344.0, 'virtualmem': 30861475840.0, 'time': 19.5355734375}} -{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 313815040.0, 'privatemem': 1271222272.0, 'nonpaged': 1756064.0, 'virtualmem': 30874058752.0, 'time': 19.61661875}} -{'var': [('concurrency', 7168), ('args', '-test ums-gated')], 'result': {'workingset': 314990592.0, 'privatemem': 1271472128.0, 'nonpaged': 1755624.0, 'virtualmem': 30865735680.0, 'time': 20.050821875}} -{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38105088.0, 'privatemem': 40636416.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 14.0955625}} -{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37982208.0, 'privatemem': 40583168.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.040196875}} -{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38129664.0, 'privatemem': 40685568.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.042221875}} -{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 38043648.0, 'privatemem': 40665088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 14.1191921875}} -{'var': [('concurrency', 8192), ('args', '-test async-gated')], 'result': {'workingset': 37933056.0, 'privatemem': 40538112.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.0314734375}} -{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 356925440.0, 'privatemem': 1448673280.0, 'nonpaged': 2001264.0, 'virtualmem': 35157557248.0, 'time': 20.15775}} -{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 354324480.0, 'privatemem': 1447530496.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.9642671875}} -{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355999744.0, 'privatemem': 1446727680.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 19.937840625}} -{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355708928.0, 'privatemem': 1447718912.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 21.3836453125}} -{'var': [('concurrency', 8192), ('args', '-test ums-gated')], 'result': {'workingset': 355086336.0, 'privatemem': 1448427520.0, 'nonpaged': 2001984.0, 'virtualmem': 35170140160.0, 'time': 20.5806625}} -{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40574976.0, 'privatemem': 42999808.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.212690625}} -{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40849408.0, 'privatemem': 43442176.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.26136875}} -{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40611840.0, 'privatemem': 43065344.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.2927234375}} -{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 35049472.0, 'privatemem': 37515264.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 14.2932515625}} -{'var': [('concurrency', 10240), ('args', '-test async-gated')], 'result': {'workingset': 40902656.0, 'privatemem': 43450368.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.29265625}} -{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437157888.0, 'privatemem': 1799569408.0, 'nonpaged': 2493704.0, 'virtualmem': 43789238272.0, 'time': 22.39598125}} -{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 438943744.0, 'privatemem': 1800122368.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3933875}} -{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 454443008.0, 'privatemem': 1816186880.0, 'nonpaged': 2493264.0, 'virtualmem': 43797430272.0, 'time': 22.156965625}} -{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 441925632.0, 'privatemem': 1810481152.0, 'nonpaged': 2503344.0, 'virtualmem': 43973591040.0, 'time': 22.4793375}} -{'var': [('concurrency', 10240), ('args', '-test ums-gated')], 'result': {'workingset': 437071872.0, 'privatemem': 1798299648.0, 'nonpaged': 2493624.0, 'virtualmem': 43789238272.0, 'time': 22.3045375}} -{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43515904.0, 'privatemem': 45961216.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.59280625}} -{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46112768.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.596046875}} -{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43720704.0, 'privatemem': 46157824.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.590865625}} -{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43683840.0, 'privatemem': 46100480.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.609971875}} -{'var': [('concurrency', 12288), ('args', '-test async-gated')], 'result': {'workingset': 43429888.0, 'privatemem': 45940736.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 14.6273390625}} -{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 516640768.0, 'privatemem': 2149273600.0, 'nonpaged': 2984784.0, 'virtualmem': 52399816704.0, 'time': 26.321934375}} -{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 517148672.0, 'privatemem': 2152136704.0, 'nonpaged': 2986944.0, 'virtualmem': 52437565440.0, 'time': 26.177103125}} -{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 523063296.0, 'privatemem': 2156064768.0, 'nonpaged': 2985504.0, 'virtualmem': 52412399616.0, 'time': 26.05946875}} -{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 518561792.0, 'privatemem': 2162417664.0, 'nonpaged': 2994864.0, 'virtualmem': 52575977472.0, 'time': 28.18605}} -{'var': [('concurrency', 12288), ('args', '-test ums-gated')], 'result': {'workingset': 525058048.0, 'privatemem': 2157924352.0, 'nonpaged': 2985264.0, 'virtualmem': 52408205312.0, 'time': 26.42195625}} -{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40148992.0, 'privatemem': 42582016.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.0295875}} -{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 40206336.0, 'privatemem': 42512384.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.990478125}} -{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 45486080.0, 'privatemem': 47845376.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 14.9103515625}} -{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 44941312.0, 'privatemem': 47333376.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.9739078125}} -{'var': [('concurrency', 14336), ('args', '-test async-gated')], 'result': {'workingset': 46559232.0, 'privatemem': 49074176.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 14.99918125}} -{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 601858048.0, 'privatemem': 2509008896.0, 'nonpaged': 3485304.0, 'virtualmem': 61158797312.0, 'time': 28.8111328125}} -{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 604540928.0, 'privatemem': 2506592256.0, 'nonpaged': 3477504.0, 'virtualmem': 61023174656.0, 'time': 28.554359375}} -{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 607997952.0, 'privatemem': 2508111872.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.05818125}} -{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 606982144.0, 'privatemem': 2510180352.0, 'nonpaged': 3477024.0, 'virtualmem': 61014786048.0, 'time': 29.6098046875}} -{'var': [('concurrency', 14336), ('args', '-test ums-gated')], 'result': {'workingset': 603512832.0, 'privatemem': 2506928128.0, 'nonpaged': 3478584.0, 'virtualmem': 61041356800.0, 'time': 30.173225}} -{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42070016.0, 'privatemem': 44314624.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2156484375}} -{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42672128.0, 'privatemem': 44982272.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 16.160125}} -{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42905600.0, 'privatemem': 45236224.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.2525890625}} -{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 43896832.0, 'privatemem': 46153728.0, 'nonpaged': 25384.0, 'virtualmem': 556580864.0, 'time': 15.3214}} -{'var': [('concurrency', 16384), ('args', '-test async-gated')], 'result': {'workingset': 42004480.0, 'privatemem': 44298240.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.23181875}} -{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 689721344.0, 'privatemem': 2865324032.0, 'nonpaged': 3968784.0, 'virtualmem': 69622706176.0, 'time': 31.0380265625}} -{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 701034496.0, 'privatemem': 2882179072.0, 'nonpaged': 3982704.0, 'virtualmem': 69865975808.0, 'time': 31.334315625}} -{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 685584384.0, 'privatemem': 2856980480.0, 'nonpaged': 3968664.0, 'virtualmem': 69621301248.0, 'time': 33.5692328125}} -{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 697085952.0, 'privatemem': 2868523008.0, 'nonpaged': 3968784.0, 'virtualmem': 69637881856.0, 'time': 30.9457953125}} -{'var': [('concurrency', 16384), ('args', '-test ums-gated')], 'result': {'workingset': 690245632.0, 'privatemem': 2862125056.0, 'nonpaged': 3970344.0, 'virtualmem': 69650661376.0, 'time': 33.4727609375}} -{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55869440.0, 'privatemem': 58114048.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.7086890625}} -{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 56160256.0, 'privatemem': 58540032.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 15.7096078125}} -{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 49836032.0, 'privatemem': 52043776.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.2957859375}} -{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 55492608.0, 'privatemem': 57851904.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.5145359375}} -{'var': [('concurrency', 20480), ('args', '-test async-gated')], 'result': {'workingset': 47857664.0, 'privatemem': 50147328.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.8469078125}} -{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 862195712.0, 'privatemem': 3575685120.0, 'nonpaged': 4952784.0, 'virtualmem': 86889738240.0, 'time': 40.3810609375}} -{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 865746944.0, 'privatemem': 3578298368.0, 'nonpaged': 4952304.0, 'virtualmem': 86881349632.0, 'time': 36.3784328125}} -{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 869675008.0, 'privatemem': 3581808640.0, 'nonpaged': 4952544.0, 'virtualmem': 86885543936.0, 'time': 38.871209375}} -{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 860774400.0, 'privatemem': 3582889984.0, 'nonpaged': 4966464.0, 'virtualmem': 87128813568.0, 'time': 43.21194375}} -{'var': [('concurrency', 20480), ('args', '-test ums-gated')], 'result': {'workingset': 855191552.0, 'privatemem': 3567927296.0, 'nonpaged': 4952904.0, 'virtualmem': 86877351936.0, 'time': 38.48225625}} -{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57565184.0, 'privatemem': 59461632.0, 'nonpaged': 25880.0, 'virtualmem': 564969472.0, 'time': 16.1426484375}} -{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 54370304.0, 'privatemem': 56492032.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 16.101009375}} -{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 62488576.0, 'privatemem': 64598016.0, 'nonpaged': 25400.0, 'virtualmem': 556580864.0, 'time': 15.84624375}} -{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 57757696.0, 'privatemem': 59613184.0, 'nonpaged': 25640.0, 'virtualmem': 569163776.0, 'time': 15.9433421875}} -{'var': [('concurrency', 24576), ('args', '-test async-gated')], 'result': {'workingset': 67629056.0, 'privatemem': 69304320.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.0379890625}} -{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028907008.0, 'privatemem': 4283650048.0, 'nonpaged': 5936184.0, 'virtualmem': 104104235008.0, 'time': 53.8624046875}} -{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037115392.0, 'privatemem': 4290715648.0, 'nonpaged': 5936304.0, 'virtualmem': 104120815616.0, 'time': 53.877346875}} -{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1037705216.0, 'privatemem': 4291125248.0, 'nonpaged': 5935824.0, 'virtualmem': 104112427008.0, 'time': 54.8691671875}} -{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1043337216.0, 'privatemem': 4301135872.0, 'nonpaged': 5935824.0, 'virtualmem': 104111026176.0, 'time': 46.317490625}} -{'var': [('concurrency', 24576), ('args', '-test ums-gated')], 'result': {'workingset': 1028558848.0, 'privatemem': 4282368000.0, 'nonpaged': 5936424.0, 'virtualmem': 104108429312.0, 'time': 53.502359375}} -{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73793536.0, 'privatemem': 75640832.0, 'nonpaged': 26600.0, 'virtualmem': 577552384.0, 'time': 16.6419671875}} -{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74006528.0, 'privatemem': 75755520.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 16.59216875}} -{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 74121216.0, 'privatemem': 75894784.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 16.6399796875}} -{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 75317248.0, 'privatemem': 77017088.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.6508421875}} -{'var': [('concurrency', 28672), ('args', '-test async-gated')], 'result': {'workingset': 73236480.0, 'privatemem': 75030528.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 16.776903125}} -{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1193185280.0, 'privatemem': 4992319488.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 59.2310265625}} -{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186713600.0, 'privatemem': 4982370304.0, 'nonpaged': 6919584.0, 'virtualmem': 121317330944.0, 'time': 62.308228125}} -{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1204101120.0, 'privatemem': 5004546048.0, 'nonpaged': 6919704.0, 'virtualmem': 121333911552.0, 'time': 59.4607328125}} -{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1186025472.0, 'privatemem': 4979195904.0, 'nonpaged': 6919824.0, 'virtualmem': 121321525248.0, 'time': 68.2966625}} -{'var': [('concurrency', 28672), ('args', '-test ums-gated')], 'result': {'workingset': 1190494208.0, 'privatemem': 4990369792.0, 'nonpaged': 6919104.0, 'virtualmem': 121308942336.0, 'time': 65.9037140625}} -{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 69914624.0, 'privatemem': 71544832.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.5821546875}} -{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 82804736.0, 'privatemem': 84516864.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4147265625}} -{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 80211968.0, 'privatemem': 81952768.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 17.2119453125}} -{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 72941568.0, 'privatemem': 74739712.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.0826671875}} -{'var': [('concurrency', 32768), ('args', '-test async-gated')], 'result': {'workingset': 57122816.0, 'privatemem': 59056128.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 15.8496921875}} -{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1363570688.0, 'privatemem': 5696401408.0, 'nonpaged': 7902864.0, 'virtualmem': 138542813184.0, 'time': 77.319371875}} -{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1359228928.0, 'privatemem': 5693067264.0, 'nonpaged': 7902504.0, 'virtualmem': 138522038272.0, 'time': 75.611196875}} -{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1382010880.0, 'privatemem': 5722746880.0, 'nonpaged': 7903224.0, 'virtualmem': 138563588096.0, 'time': 75.43135625}} -{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1366474752.0, 'privatemem': 5719846912.0, 'nonpaged': 7935264.0, 'virtualmem': 139092529152.0, 'time': 77.2984921875}} -{'var': [('concurrency', 32768), ('args', '-test ums-gated')], 'result': {'workingset': 1380454400.0, 'privatemem': 5713457152.0, 'nonpaged': 7902744.0, 'virtualmem': 138555199488.0, 'time': 72.9519984375}} -{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 82169856.0, 'privatemem': 84209664.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 18.2689421875}} -{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 86765568.0, 'privatemem': 88666112.0, 'nonpaged': 25768.0, 'virtualmem': 564969472.0, 'time': 17.703690625}} -{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89808896.0, 'privatemem': 91951104.0, 'nonpaged': 25744.0, 'virtualmem': 562872320.0, 'time': 17.698275}} -{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 83464192.0, 'privatemem': 84893696.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 17.8156953125}} -{'var': [('concurrency', 40960), ('args', '-test async-gated')], 'result': {'workingset': 89182208.0, 'privatemem': 91365376.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 17.637353125}} -{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1688113152.0, 'privatemem': 7102902272.0, 'nonpaged': 9870744.0, 'virtualmem': 172987879424.0, 'time': 109.5945375}} -{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681657856.0, 'privatemem': 7097241600.0, 'nonpaged': 9870264.0, 'virtualmem': 172979490816.0, 'time': 112.0583734375}} -{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1701982208.0, 'privatemem': 7125585920.0, 'nonpaged': 9876984.0, 'virtualmem': 173109383168.0, 'time': 108.868828125}} -{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1696256000.0, 'privatemem': 7110664192.0, 'nonpaged': 9870384.0, 'virtualmem': 172979556352.0, 'time': 100.987990625}} -{'var': [('concurrency', 40960), ('args', '-test ums-gated')], 'result': {'workingset': 1681092608.0, 'privatemem': 7102992384.0, 'nonpaged': 9881424.0, 'virtualmem': 173160042496.0, 'time': 103.1147171875}} -{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 88752128.0, 'privatemem': 90644480.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.194690625}} -{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 91697152.0, 'privatemem': 93396992.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 19.1130046875}} -{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 70430720.0, 'privatemem': 72364032.0, 'nonpaged': 26240.0, 'virtualmem': 571260928.0, 'time': 17.7690265625}} -{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 85979136.0, 'privatemem': 87822336.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 19.166028125}} -{'var': [('concurrency', 49152), ('args', '-test async-gated')], 'result': {'workingset': 87728128.0, 'privatemem': 89387008.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.178809375}} -{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2026475520.0, 'privatemem': 8518123520.0, 'nonpaged': 11837784.0, 'virtualmem': 207459684352.0, 'time': 140.7092328125}} -{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2036518912.0, 'privatemem': 8542306304.0, 'nonpaged': 11840544.0, 'virtualmem': 207512752128.0, 'time': 147.6286140625}} -{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2027098112.0, 'privatemem': 8528797696.0, 'nonpaged': 11837424.0, 'virtualmem': 207455424512.0, 'time': 157.0997796875}} -{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2029830144.0, 'privatemem': 8523378688.0, 'nonpaged': 11838144.0, 'virtualmem': 207470809088.0, 'time': 149.35805}} -{'var': [('concurrency', 49152), ('args', '-test ums-gated')], 'result': {'workingset': 2018607104.0, 'privatemem': 8512258048.0, 'nonpaged': 11837544.0, 'virtualmem': 207443038208.0, 'time': 156.43776875}} -{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 110104576.0, 'privatemem': 112001024.0, 'nonpaged': 25888.0, 'virtualmem': 567066624.0, 'time': 19.1979890625}} -{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 117399552.0, 'privatemem': 118956032.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.72220625}} -{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 102563840.0, 'privatemem': 104300544.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.6945328125}} -{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 105697280.0, 'privatemem': 107380736.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 19.43420625}} -{'var': [('concurrency', 57344), ('args', '-test async-gated')], 'result': {'workingset': 106532864.0, 'privatemem': 108306432.0, 'nonpaged': 26000.0, 'virtualmem': 567066624.0, 'time': 19.3152046875}} -{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2363232256.0, 'privatemem': 9939460096.0, 'nonpaged': 13804464.0, 'virtualmem': 241888612352.0, 'time': 184.053434375}} -{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2365878272.0, 'privatemem': 9953259520.0, 'nonpaged': 13804344.0, 'virtualmem': 241900998656.0, 'time': 192.2616015625}} -{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2358566912.0, 'privatemem': 9937661952.0, 'nonpaged': 13806264.0, 'virtualmem': 241918038016.0, 'time': 189.8282234375}} -{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2342895616.0, 'privatemem': 9925849088.0, 'nonpaged': 13804224.0, 'virtualmem': 241884418048.0, 'time': 182.3936078125}} -{'var': [('concurrency', 57344), ('args', '-test ums-gated')], 'result': {'workingset': 2347986944.0, 'privatemem': 9933496320.0, 'nonpaged': 13804824.0, 'virtualmem': 241892872192.0, 'time': 186.212921875}} -{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 130637824.0, 'privatemem': 132468736.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 20.00561875}} -{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 115064832.0, 'privatemem': 116396032.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 20.3946609375}} -{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 72556544.0, 'privatemem': 74584064.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 17.1177015625}} -{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 112943104.0, 'privatemem': 114147328.0, 'nonpaged': 26120.0, 'virtualmem': 569163776.0, 'time': 20.2790203125}} -{'var': [('concurrency', 65536), ('args', '-test async-gated')], 'result': {'workingset': 129822720.0, 'privatemem': 131096576.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 20.95596875}} -{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2690383872.0, 'privatemem': 11338743808.0, 'nonpaged': 15772944.0, 'virtualmem': 276378443776.0, 'time': 247.372325}} -{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2684055552.0, 'privatemem': 11335376896.0, 'nonpaged': 15771504.0, 'virtualmem': 276344889344.0, 'time': 240.684809375}} -{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2701897728.0, 'privatemem': 11360075776.0, 'nonpaged': 15772344.0, 'virtualmem': 276374052864.0, 'time': 235.606675}} -{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2961162240.0, 'privatemem': 11630002176.0, 'nonpaged': 15773904.0, 'virtualmem': 276618567680.0, 'time': 277.3269875}} -{'var': [('concurrency', 65536), ('args', '-test ums-gated')], 'result': {'workingset': 2682052608.0, 'privatemem': 11340992512.0, 'nonpaged': 15776304.0, 'virtualmem': 276428775424.0, 'time': 244.7224234375}} -{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 138235904.0, 'privatemem': 139558912.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 21.6494125}} -{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 89427968.0, 'privatemem': 90931200.0, 'nonpaged': 25528.0, 'virtualmem': 560775168.0, 'time': 17.4579984375}} -{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 130588672.0, 'privatemem': 131649536.0, 'nonpaged': 26008.0, 'virtualmem': 569163776.0, 'time': 21.278078125}} -{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 135176192.0, 'privatemem': 136491008.0, 'nonpaged': 25640.0, 'virtualmem': 560775168.0, 'time': 21.5131796875}} -{'var': [('concurrency', 81920), ('args', '-test async-gated')], 'result': {'workingset': 127688704.0, 'privatemem': 129499136.0, 'nonpaged': 26728.0, 'virtualmem': 581746688.0, 'time': 19.93003125}} -{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3732779008.0, 'privatemem': 14553665536.0, 'nonpaged': 19709064.0, 'virtualmem': 345628565504.0, 'time': 353.601725}} -{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3335438336.0, 'privatemem': 14157639680.0, 'nonpaged': 19704744.0, 'virtualmem': 345205465088.0, 'time': 356.084828125}} -{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3416276992.0, 'privatemem': 14252584960.0, 'nonpaged': 19705824.0, 'virtualmem': 345296756736.0, 'time': 364.665215625}} -{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3340185600.0, 'privatemem': 14166282240.0, 'nonpaged': 19705344.0, 'virtualmem': 345218048000.0, 'time': 330.89671875}} -{'var': [('concurrency', 81920), ('args', '-test ums-gated')], 'result': {'workingset': 3341864960.0, 'privatemem': 14169149440.0, 'nonpaged': 19707504.0, 'virtualmem': 345255796736.0, 'time': 352.603725}} -{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 119099392.0, 'privatemem': 120713216.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 21.3428921875}} -{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139829248.0, 'privatemem': 141701120.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 23.1737}} -{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 151707648.0, 'privatemem': 153325568.0, 'nonpaged': 26488.0, 'virtualmem': 577552384.0, 'time': 22.1648703125}} -{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 139603968.0, 'privatemem': 141705216.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 24.3582796875}} -{'var': [('concurrency', 98304), ('args', '-test async-gated')], 'result': {'workingset': 126025728.0, 'privatemem': 128827392.0, 'nonpaged': 27568.0, 'virtualmem': 596426752.0, 'time': 21.027715625}} -{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3993194496.0, 'privatemem': 16967299072.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 480.1536890625}} -{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 3999387648.0, 'privatemem': 16987381760.0, 'nonpaged': 23638824.0, 'virtualmem': 414117388288.0, 'time': 516.035265625}} -{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4001804288.0, 'privatemem': 17038946304.0, 'nonpaged': 23718144.0, 'virtualmem': 415501574144.0, 'time': 483.755525}} -{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4013903872.0, 'privatemem': 17002704896.0, 'nonpaged': 23639544.0, 'virtualmem': 414158938112.0, 'time': 503.345384375}} -{'var': [('concurrency', 98304), ('args', '-test ums-gated')], 'result': {'workingset': 4039008256.0, 'privatemem': 17174925312.0, 'nonpaged': 23918784.0, 'virtualmem': 419020464128.0, 'time': 505.355275}} -{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 164077568.0, 'privatemem': 165376000.0, 'nonpaged': 25648.0, 'virtualmem': 562872320.0, 'time': 23.6242703125}} -{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 136712192.0, 'privatemem': 138002432.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.1367515625}} -{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 118976512.0, 'privatemem': 120524800.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 23.2383796875}} -{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 127246336.0, 'privatemem': 128696320.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 23.4868671875}} -{'var': [('concurrency', 114688), ('args', '-test async-gated')], 'result': {'workingset': 201854976.0, 'privatemem': 202383360.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.734434375}} -{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4636082176.0, 'privatemem': 19810603008.0, 'nonpaged': 27575064.0, 'virtualmem': 483073843200.0, 'time': 602.0996375}} -{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4602040320.0, 'privatemem': 19810873344.0, 'nonpaged': 27579744.0, 'virtualmem': 483141148672.0, 'time': 659.99125625}} -{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4591165440.0, 'privatemem': 19790200832.0, 'nonpaged': 27573024.0, 'virtualmem': 483023708160.0, 'time': 583.1214046875}} -{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4639674368.0, 'privatemem': 19800694784.0, 'nonpaged': 27572544.0, 'virtualmem': 483015319552.0, 'time': 595.6076765625}} -{'var': [('concurrency', 114688), ('args', '-test ums-gated')], 'result': {'workingset': 4615213056.0, 'privatemem': 19768594432.0, 'nonpaged': 27572304.0, 'virtualmem': 483011125248.0, 'time': 585.95591875}} -{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 122953728.0, 'privatemem': 124391424.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 22.2635234375}} -{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 128253952.0, 'privatemem': 129671168.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.54289375}} -{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 130244608.0, 'privatemem': 131567616.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 21.3423078125}} -{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 120819712.0, 'privatemem': 121860096.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 22.1759359375}} -{'var': [('concurrency', 131072), ('args', '-test async-gated')], 'result': {'workingset': 197222400.0, 'privatemem': 197992448.0, 'nonpaged': 26128.0, 'virtualmem': 571260928.0, 'time': 26.0388765625}} -{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5291032576.0, 'privatemem': 22605094912.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 769.2572203125}} -{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5268750336.0, 'privatemem': 22580580352.0, 'nonpaged': 31506624.0, 'virtualmem': 551903141888.0, 'time': 715.4761953125}} -{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5275197440.0, 'privatemem': 22597181440.0, 'nonpaged': 31506504.0, 'virtualmem': 551886561280.0, 'time': 743.6708078125}} -{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5559996416.0, 'privatemem': 22927003648.0, 'nonpaged': 31508664.0, 'virtualmem': 552185012224.0, 'time': 777.7286765625}} -{'var': [('concurrency', 131072), ('args', '-test ums-gated')], 'result': {'workingset': 5265473536.0, 'privatemem': 22609494016.0, 'nonpaged': 31506384.0, 'virtualmem': 551898947584.0, 'time': 774.769990625}} -{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 161509376.0, 'privatemem': 163639296.0, 'nonpaged': 26720.0, 'virtualmem': 579649536.0, 'time': 29.432303125}} -{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 152326144.0, 'privatemem': 153423872.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 24.661028125}} -{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 148279296.0, 'privatemem': 150319104.0, 'nonpaged': 26368.0, 'virtualmem': 575455232.0, 'time': 25.9785390625}} -{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 153616384.0, 'privatemem': 154677248.0, 'nonpaged': 26248.0, 'virtualmem': 573358080.0, 'time': 25.02185}} -{'var': [('concurrency', 163840), ('args', '-test async-gated')], 'result': {'workingset': 154402816.0, 'privatemem': 155430912.0, 'nonpaged': 26360.0, 'virtualmem': 573358080.0, 'time': 25.0472640625}} -{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6044577792.0, 'privatemem': 28556054528.0, 'nonpaged': 39377064.0, 'virtualmem': 690026848256.0, 'time': 238880.438532812}} -{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6581481472.0, 'privatemem': 28245975040.0, 'nonpaged': 39374664.0, 'virtualmem': 689695236096.0, 'time': 1124.5557}} -{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 5939179520.0, 'privatemem': 28300779520.0, 'nonpaged': 39375144.0, 'virtualmem': 689703624704.0, 'time': 61740.7140578125}} -{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597120000.0, 'privatemem': 28281757696.0, 'nonpaged': 39374904.0, 'virtualmem': 689728397312.0, 'time': 1146.400846875}} -{'var': [('concurrency', 163840), ('args', '-test ums-gated')], 'result': {'workingset': 6597758976.0, 'privatemem': 28234469376.0, 'nonpaged': 39375264.0, 'virtualmem': 689703690240.0, 'time': 1061.4835671875}} -{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 187748352.0, 'privatemem': 191131648.0, 'nonpaged': 26840.0, 'virtualmem': 581292032.0, 'time': 28.6244015625}} -{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 186040320.0, 'privatemem': 189222912.0, 'nonpaged': 27448.0, 'virtualmem': 593874944.0, 'time': 27.09115625}} -{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 191225856.0, 'privatemem': 192925696.0, 'nonpaged': 27088.0, 'virtualmem': 588038144.0, 'time': 27.2597046875}} -{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 182910976.0, 'privatemem': 184160256.0, 'nonpaged': 25760.0, 'virtualmem': 562872320.0, 'time': 26.3374671875}} -{'var': [('concurrency', 196608), ('args', '-test async-gated')], 'result': {'workingset': 178884608.0, 'privatemem': 179732480.0, 'nonpaged': 26608.0, 'virtualmem': 579649536.0, 'time': 26.914534375}} diff --git a/Rx/CPP/testbench/testbench.cpp b/Rx/CPP/testbench/testbench.cpp deleted file mode 100644 index 4fd5e8c..0000000 --- a/Rx/CPP/testbench/testbench.cpp +++ /dev/null @@ -1,652 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. - -// testbench.cpp : Defines the entry point for the console application. -// - -#include "cpprx/rx.hpp" -#include "cpplinq/linq.hpp" - -#include -#include -#include -#include -#include -#include -#include - -using namespace std; - -bool IsPrime(int x); - -struct Count { - Count() : subscriptions(0), nexts(0), completions(0), errors(0), disposals(0) {} - std::atomic subscriptions; - std::atomic nexts; - std::atomic completions; - std::atomic errors; - std::atomic disposals; -}; -template -std::shared_ptr> Record( - const std::shared_ptr>& source, - Count* count -) -{ - return rxcpp::CreateObservable( - [=](std::shared_ptr> observer) -> rxcpp::Disposable - { - ++count->subscriptions; - rxcpp::ComposableDisposable cd; - cd.Add(rxcpp::Disposable([=](){ - ++count->disposals;})); - cd.Add(rxcpp::Subscribe( - source, - // on next - [=](T element) - { - ++count->nexts; - observer->OnNext(std::move(element)); - }, - // on completed - [=] - { - ++count->completions; - observer->OnCompleted(); - }, - // on error - [=](const std::exception_ptr& error) - { - ++count->errors; - observer->OnError(error); - })); - return cd; - }); -} -struct record {}; -template -rxcpp::Binder>> rxcpp_chain(record&&, const std::shared_ptr>& source, Count* count) { - return rxcpp::from(Record(source, count)); -} - -vector vector_range(int start, int end) -{ - vector v; - for (int i = start; i < end; ++i) - v.push_back(i); - return v; -} - -void IxToRx(int n) { - Count sourcecount, takencount, observedcount; - - std::cout << "IxToRx: first " << n << " primes squared" << endl; - auto values = vector_range(2, n * 10); - - auto primes = cpplinq::from(values) - .where(IsPrime) - .select([](int x) { return std::make_pair(x, x*x); }); - - auto output = std::make_shared(); - rxcpp::from(rxcpp::Iterate(primes)) - .template chain(&sourcecount) - .take(n) - .template chain(&takencount) - .observe_on(output) - .template chain(&observedcount) - .for_each(rxcpp::MakeTupleDispatch( - [](int p, int s) { - cout << p << " =square=> " << s << endl; - })); - - cout << "location: subscriptions, nexts, completions, errors, disposals" << endl; - cout << "sourcecount: " << sourcecount.subscriptions << ", " << sourcecount.nexts << ", " << sourcecount.completions << ", " << sourcecount.errors << ", " << sourcecount.disposals << endl; - cout << "takencount: " << takencount.subscriptions << ", " << takencount.nexts << ", " << takencount.completions << ", " << takencount.errors << ", " << takencount.disposals << endl; - cout << "observedcount: " << observedcount.subscriptions << ", " << observedcount.nexts << ", " << observedcount.completions << ", " << observedcount.errors << ", " << observedcount.disposals << endl; -} - -void PrintPrimes(int n) -{ - std::cout << "Rx: first " << n << " primes squared" << endl; - auto values = rxcpp::Range(2); // infinite (until overflow) stream of integers - rxcpp::from(values) - .where(IsPrime) - .materialize() - .dematerialize() - .select([](int x) { return std::make_pair(x, x*x); }) - .take(n) - .for_each(rxcpp::MakeTupleDispatch( - [](int p, int s) { - cout << p << " =square=> " << s << endl; - })); -} - -void Scan() -{ - int test = 0; - auto next = [&](int i) { - cout << "next " << test << ":" << i << endl; - }; - auto complete = [&]() { - cout << "completed " << test << endl; - }; - auto error = [&](std::exception_ptr e) { - try { - std::rethrow_exception(e); - } - catch(std::exception ex) { - cout << ex.what() << endl; - } - }; - - auto input = std::make_shared(); - - auto add = [](int x, int y){return x + y;}; - - // Usage - auto obs1 = rxcpp::from(rxcpp::Empty(input)).scan(add); - auto obs2 = rxcpp::from(rxcpp::Empty(input)).scan(0, add); - - auto obs3 = rxcpp::from(rxcpp::Range(1, 3, 1, input)).scan(add); - auto obs4 = rxcpp::from(rxcpp::Range(1, 3, 1, input)).scan(0, add); - - test = 1; - obs1.subscribe(next, complete, error); - // => completed 1 - - test = 2; - obs2.subscribe(next, complete, error); - // => next 2:0 - // => completed 2 - - test = 3; - obs3.subscribe(next, complete, error); - // => next 3:1 - // => next 3:3 - // => next 3:6 - // => completed 3 - - test = 4; - obs4.subscribe(next, complete, error); - // => next 4:1 - // => next 4:3 - // => next 4:6 - // => completed 4 -} - -void Concat(int n) -{ - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .where(IsPrime) - .select([](int prime) -> std::tuple {this_thread::yield(); return std::make_tuple("1:", prime);}) - .take(n/2); - - auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers - auto s2 = rxcpp::from(values2) - .subscribe_on(input2) - .where(IsPrime) - .select([](int prime) -> std::tuple {this_thread::yield(); return std::make_tuple("2:", prime);}) - .take(n/2); - - rxcpp::from(s2) - .concat(s1) - .take(n) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](const char* s, int p) { - cout << s << " =concat=> " << p << endl; - })); -} - -void Combine(int n) -{ - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .where(IsPrime) - .select([](int prime) -> int {this_thread::yield(); return prime;}); - - auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers - rxcpp::from(values2) - .subscribe_on(input2) - .where(IsPrime) - .select([](int prime) -> int {this_thread::yield(); return prime;}) - .combine_latest(s1) - .take(n) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](int p2, int p1) { - cout << p2 << " =combined=> " << p1 << endl; - })); -} - - - -template -void Zip(int n) -{ - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - Count s1count, s2count, zipcount, takecount, outputcount; - - auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .where(IsPrime) - .template chain(&s1count) - .select([](int prime) -> int {this_thread::yield(); return prime;}); - - auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers - rxcpp::from(values2) - .subscribe_on(input2) - .where(IsPrime) - .template chain(&s2count) - .select([](int prime) -> int {this_thread::yield(); return prime;}) - .zip(s1) - .template chain(&zipcount) - .take(n) - .template chain(&takecount) - .observe_on(output) - .template chain(&outputcount) - .for_each(rxcpp::MakeTupleDispatch( - [](int p2, int p1) { - cout << p2 << " =zipped=> " << p1 << endl; - })); - - cout << "location: subscriptions, nexts, completions, errors, disposals" << endl; - cout << "s1count: " << s1count.subscriptions << ", " << s1count.nexts << ", " << s1count.completions << ", " << s1count.errors << ", " << s1count.disposals << endl; - cout << "s2count: " << s2count.subscriptions << ", " << s2count.nexts << ", " << s2count.completions << ", " << s2count.errors << ", " << s2count.disposals << endl; - cout << "zipcount: " << zipcount.subscriptions << ", " << zipcount.nexts << ", " << zipcount.completions << ", " << zipcount.errors << ", " << zipcount.disposals << endl; - cout << "takecount: " << takecount.subscriptions << ", " << takecount.nexts << ", " << takecount.completions << ", " << takecount.errors << ", " << takecount.disposals << endl; - cout << "outputcount: " << outputcount.subscriptions << ", " << outputcount.nexts << ", " << outputcount.completions << ", " << outputcount.errors << ", " << outputcount.disposals << endl; -} - -void Merge(int n) -{ - auto input1 = std::make_shared(); - auto input2 = std::make_shared(); - auto output = std::make_shared(); - - cout << "merge==> : " << endl; - - auto values1 = rxcpp::Range(100); // infinite (until overflow) stream of integers - auto s1 = rxcpp::from(values1) - .subscribe_on(input1) - .where(IsPrime) - .select([](int prime1) -> std::tuple {this_thread::yield(); return std::make_tuple("1: ", prime1);}); - - auto values2 = rxcpp::Range(2); // infinite (until overflow) stream of integers - rxcpp::from(values2) - .subscribe_on(input2) - .where(IsPrime) - .select([](int prime2) -> std::tuple {this_thread::yield(); return std::make_tuple("2: ", prime2);}) - .merge(s1) - .take(n) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](const char* s, int p) { - cout << s << p << endl; - })); -} - -void RefCount(int n) -{ - auto loop = std::make_shared(); - - auto values1 = rxcpp::from(rxcpp::Range(1)) - .where(IsPrime) - .select([](int p) -> int {cout << endl << "producing: " << p << "-> "; return p;}) - .publish() - .ref_count(); // infinite (until overflow) stream of prime integers - - auto v1 = rxcpp::from(values1) - .select([](int prime1) -> std::tuple {return std::make_tuple("1: ", prime1);}); - - auto v2 = rxcpp::from(values1) - .select([](int prime1) -> std::tuple {return std::make_tuple("2: ", prime1);}); - - cout << "Merge 2 subscriptions to published primes:"; - rxcpp::from(v1) - .merge(v2) - .subscribe_on(loop) - .take(n) - .for_each(rxcpp::MakeTupleDispatch( - [](const char* s, int p) { - cout << s << p << ", "; - })); - - auto values2 = rxcpp::from(rxcpp::Range(100)) - .where(IsPrime) - .select([](int p) -> int {cout << endl << "producing: " << p << "-> "; return p;}) - .publish(1000) - .ref_count(); // infinite (until overflow) stream of prime integers - - cout << endl << "Subscription 1 - published primes:" << endl; - rxcpp::from(values2) - .subscribe_on(loop) - .take(n/2) - .for_each( - [](int p) { - cout << p << ", "; - }); - - cout << endl << "Subscription 2 - published primes:" << endl; - rxcpp::from(values2) - .subscribe_on(loop) - .take(n/2) - .for_each( - [](int p) { - cout << p << ", "; - }); - - auto values3 = rxcpp::from(rxcpp::Range(200)) - .where(IsPrime) - .select([](int p) -> int {cout << endl << "producing: " << p << "-> "; return p;}) - .take(n/2) - .publish_last() - .ref_count(); // last of n/2 prime integers - - cout << endl << "Subscription 1 - last published prime:"; - rxcpp::from(values3) - .subscribe_on(loop) - .for_each( - [](int p) { - cout << p << ", "; - }); - - cout << endl << "Subscription 2 - last published prime:" << endl; - rxcpp::from(values3) - .subscribe_on(loop) - .for_each( - [](int p) { - cout << p << ", "; - }); - cout << endl; -} - - -void PrintIntervals(int n) { - using namespace std::chrono; - typedef steady_clock clock; - struct Tick { - Tick(size_t c, clock::time_point at) : cursor(c), at(at) {} - size_t cursor; - clock::time_point at; - }; - auto source = std::make_shared(); - auto subject = rxcpp::CreateSubject(); - - cout << n << " Intervals of .5 second: " << endl; - rxcpp::from(subject) - .zip(rxcpp::from(subject).skip(1)) - .select(rxcpp::MakeTupleDispatch( - [=](Tick a, Tick b){ - return duration_cast(b.at.time_since_epoch()) - - duration_cast(a.at.time_since_epoch());})) - .to_vector() - .subscribe( - // on next - [=](std::vector d) - { - cout << endl; - auto l = std::max_element(d.begin(), d.end()); - auto s = std::min_element(d.begin(), d.end()); - cout << "range: " << s->count() << "ms-" << l->count() << "ms" << endl; - }); - - rxcpp::from(rxcpp::Interval(std::chrono::milliseconds(500), source)) - .select([](size_t interval){return Tick(interval, clock::now());}) - .take(n) - .for_each( - // on next - [=](Tick t) - { - cout << "." << flush; - subject->OnNext(std::move(t)); - }); - subject->OnCompleted(); -} - -std::shared_ptr> Data( - string filename, - rxcpp::Scheduler::shared scheduler = std::make_shared() -); -string extract_value(const string& input, const string& key); - -void run() -{ - using namespace cpplinq; - - struct item { - string args; - int concurrency; - double time; - - item(const item& other) : args(other.args), concurrency(other.concurrency), time(other.time) { - } - item(item&& other) : args(std::move(other.args)), concurrency(std::move(other.concurrency)), time(std::move(other.time)) { - } - item(const string& input) { - args = extract_value(input, "args"); - concurrency = atoi( extract_value(input, "concurrency").c_str() ); - time = atof( extract_value(input, "time").c_str() ); - } - item& operator=(item other){ - using std::swap; - swap(args, other.args); - swap(concurrency, other.concurrency); - swap(time, other.time); - return *this; - } - }; - - auto input = std::make_shared(); - auto output = std::make_shared(); - - auto dataLines = Data("data.txt"); - - rxcpp::from(dataLines) - .subscribe_on(input) - // parse input into items - .select([](const string& line) { - return item(line);} - ) - // group items by args field - .group_by([](const item& i) { - return i.args;} - ) - // flatten concurrencies in the same args - .select_many( - [](const std::shared_ptr> & argsGroup){ - return rxcpp::from(argsGroup) - // group items by concurrency field - .group_by([](const item& i){ - return i.concurrency;} - ) - // flatten times in the same concurrency - .select_many( - [](const std::shared_ptr> & concurrencyGroup){ - return rxcpp::from(concurrencyGroup) - .select([](const item& i){ - return i.time;}) - .to_vector();}, - [](const std::shared_ptr> & concurrencyGroup, - const std::vector & times){ - return std::make_tuple(concurrencyGroup->Key(), times);} - ) - .to_vector();}, - [](const std::shared_ptr> & argsGroup, - const std::vector>> & ouputGroup){ - return std::make_tuple(argsGroup->Key(), ouputGroup);} - ) - .observe_on(output) - .for_each(rxcpp::MakeTupleDispatch( - [](const std::string& args, const std::vector>>& concurrencyGroup){ - cout<<"arguments: "<< args << endl; - cout << "concurrency, mean, |, raw_data," << endl; - for(auto& concurrencyItem : concurrencyGroup) { - rxcpp::MakeTupleDispatch( - [](int concurrency, const std::vector& rawtimes){ - cout << concurrency << ", "; - - auto n = from(rawtimes).count(); - auto sum = std::accumulate(rawtimes.begin(), rawtimes.end(), 0.0); - - cout << (sum / n) << ", |"; - - for (auto timeIter = rawtimes.begin(), end = rawtimes.end(); - timeIter != end; - ++timeIter) - { - cout << ", " << *timeIter; - } - cout << endl;})(concurrencyItem);}}) - ); -} - -template -void innerScheduler() { - auto outer = std::make_shared(); - rxcpp::Scheduler::shared inner; - std::mutex lock; - std::condition_variable wake; - outer->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { - std::lock_guard guard(lock); - inner = s; wake.notify_one(); - return rxcpp::Disposable::Empty();}); - { - std::unique_lock guard(lock); - wake.wait(guard, [&]{return !!inner;}); - } - inner->Schedule([&](rxcpp::Scheduler::shared s) -> rxcpp::Disposable { - std::lock_guard guard(lock); - inner = nullptr; wake.notify_one(); - return rxcpp::Disposable::Empty();}); - { - std::unique_lock guard(lock); - wake.wait(guard, [&]{return !inner;}); - } - cout << "innerScheduler test succeeded" << endl; -} - -int main(int argc, char* argv[]) -{ - try { - RefCount(20); - PrintIntervals(10); - IxToRx(20); - PrintPrimes(20); - cout << "Zip Immediate" << endl; - Zip(20); - cout << "Zip Current" << endl; - Zip(20); - cout << "Zip EventLoop" << endl; - Zip(20); - Combine(20); - Merge(20); - Concat(20); - - innerScheduler(); - innerScheduler(); - innerScheduler(); - - Scan(); - - run(); - } catch (exception& e) { - cerr << "exception: " << e.what() << endl; - } -} - -bool IsPrime(int x) -{ - if (x < 2) return false; - for (int i = 2; i <= x/2; ++i) - { - if (x % i == 0) - return false; - } - return true; -} - -regex key_value_pair("'([^\']*)'\\s*[:,]\\s*(\\d+(?:\\.\\d+)?|'[^']*')"); - -string extract_value(const string& input, const string& key) -{ - const std::sregex_iterator end; - for (std::sregex_iterator i(input.cbegin(), input.cend(), key_value_pair); - i != end; - ++i) - { - if ((*i)[1] == key) - { - return (*i)[2]; - } - } - throw std::range_error("search key not found"); -} - -std::shared_ptr> Data( - string filename, - rxcpp::Scheduler::shared scheduler -) -{ - return rxcpp::CreateObservable( - [=](std::shared_ptr> observer) - -> rxcpp::Disposable - { - struct State - { - State(string filename) - : cancel(false), data(filename) { - if (data.fail()) { - throw logic_error("could not find file"); - } - } - bool cancel; - ifstream data; - }; - auto state = std::make_shared(std::move(filename)); - - rxcpp::ComposableDisposable cd; - - cd.Add(rxcpp::Disposable([=]{ - state->cancel = true; - })); - - cd.Add(scheduler->Schedule( - rxcpp::fix0([=](rxcpp::Scheduler::shared s, std::function self) -> rxcpp::Disposable - { - if (state->cancel) - return rxcpp::Disposable::Empty(); - - string line; - if (!!getline(state->data, line)) - { - observer->OnNext(std::move(line)); - return s->Schedule(std::move(self)); - } - else - { - observer->OnCompleted(); - } - return rxcpp::Disposable::Empty(); - }) - )); - - return cd; - } - ); -} - diff --git a/Rx/CPP/testbench/testbench.vcxproj b/Rx/CPP/testbench/testbench.vcxproj deleted file mode 100644 index 3f0ae00..0000000 --- a/Rx/CPP/testbench/testbench.vcxproj +++ /dev/null @@ -1,93 +0,0 @@ - - - - - Debug - Win32 - - - Release - Win32 - - - - $(VCTargetsPath11) - - - {6FC6DE04-1645-457E-9728-0E8E6FCDC9EB} - Win32Proj - testbench - - - - Application - true - v110 - Unicode - - - Application - false - v110 - true - Unicode - - - - - - - - - - - - - true - $(VCInstallDir)include;..\..\..\Ix\CPP\src;..\src;$(WindowsSDK_IncludePath); - $(SolutionDir)\bin\$(Configuration)\ - obj\$(Configuration)\ - - - false - $(VCInstallDir)include;..\..\..\Ix\CPP\src;..\src;$(WindowsSDK_IncludePath); - $(SolutionDir)\bin\$(Configuration)\ - obj\$(Configuration)\ - - - - - - Level3 - Disabled - WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) - - - Console - true - - - - - Level3 - - - MaxSpeed - true - true - WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) - - - Console - true - true - true - - - - - - - - - \ No newline at end of file diff --git a/Rx/CPP/testbench/testbench.vcxproj.filters b/Rx/CPP/testbench/testbench.vcxproj.filters deleted file mode 100644 index 8afd620..0000000 --- a/Rx/CPP/testbench/testbench.vcxproj.filters +++ /dev/null @@ -1,22 +0,0 @@ - - - - - {4FC737F1-C7A5-4376-A066-2A32D752A2FF} - cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx - - - {93995380-89BD-4b04-88EB-625FBE52EBFB} - h;hpp;hxx;hm;inl;inc;xsd - - - {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} - rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - - - - Source Files - - - \ No newline at end of file diff --git a/Rx/v2/examples/pythagorian/main.cpp b/Rx/v2/examples/pythagorian/main.cpp new file mode 100644 index 0000000..d6aa6f0 --- /dev/null +++ b/Rx/v2/examples/pythagorian/main.cpp @@ -0,0 +1,50 @@ +#include "rxcpp/rx.hpp" +// create alias' to simplify code +// these are owned by the user so that +// conflicts can be managed by the user. +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; + +// At this time, RxCpp will fail to compile if the contents +// of the std namespace are merged into the global namespace +// DO NOT USE: 'using namespace std;' + +#ifdef UNICODE +int wmain(int argc, wchar_t** argv) +#else +int main(int argc, char** argv) +#endif +{ + int c = 0; + + auto triples = + rx::observable<>::range(1) + .concat_map( + [&c](int z){ + return rx::observable<>::range(1, z) + .concat_map( + [=, &c](int x){ + return rx::observable<>::range(x, z) + .filter([=, &c](int y){++c; return x*x + y*y == z*z;}) + .map([=](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}); + + int ct = 0; + + triples + .take(100) + .subscribe(rxu::apply_to([&ct](int x,int y,int z){ + ++ct; + })); + + std::cout << "concat_map pythagorian range : " << c << " filtered to, " << ct << " triplets" << std::endl; + + return 0; +} diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index f3ada84..9c6d51d 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -60,7 +60,7 @@ SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][pe auto sc = rxsc::make_immediate(); //auto sc = rxsc::make_current_thread(); - auto so = rx::syncronize_in_one_worker(sc); + auto so = rx::identity_one_worker(sc); int c = 0; int ct = 0; diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 87676b6..34ab78d 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -15,68 +15,48 @@ endif() # define some folders get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) -set(TEST_DIR ${RXCPP_DIR}/Rx/CPP/test) -set(V2_TEST_DIR ${RXCPP_DIR}/Rx/v2/test) +set(TEST_DIR ${RXCPP_DIR}/Rx/v2/test) +set(EXAMPLES_DIR ${RXCPP_DIR}/Rx/v2/examples) -include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/CPP/src ${RXCPP_DIR}/Rx/v2/src) +include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) # define the sources of the self test set(TEST_SOURCES ${TEST_DIR}/test.cpp - ${TEST_DIR}/operators/Merge.cpp - ${TEST_DIR}/operators/Return.cpp - ${TEST_DIR}/operators/Select.cpp - ${TEST_DIR}/operators/SelectMany.cpp - ${TEST_DIR}/operators/Where.cpp - ${TEST_DIR}/operators/Publish.cpp + ${TEST_DIR}/subscriptions/observer.cpp + ${TEST_DIR}/subscriptions/subscription.cpp + ${TEST_DIR}/subjects/subject.cpp + ${TEST_DIR}/sources/defer.cpp + ${TEST_DIR}/sources/interval.cpp + ${TEST_DIR}/operators/buffer.cpp + ${TEST_DIR}/operators/combine_latest.cpp + ${TEST_DIR}/operators/concat.cpp + ${TEST_DIR}/operators/merge.cpp + ${TEST_DIR}/operators/lift.cpp + ${TEST_DIR}/operators/filter.cpp + ${TEST_DIR}/operators/scan.cpp + ${TEST_DIR}/operators/take.cpp + ${TEST_DIR}/operators/publish.cpp + ${TEST_DIR}/operators/flat_map.cpp + ${TEST_DIR}/operators/concat_map.cpp + ${TEST_DIR}/operators/map.cpp ) -add_executable(rxcpp_test ${TEST_SOURCES}) +add_executable(rxcppv2_test ${TEST_SOURCES}) -# define the sources of testbench -set(TESTBENCH_SOURCES - ${RXCPP_DIR}/Rx/CPP/testbench/testbench.cpp +# define the sources of the pythagorian example +set(PYTHAGORIAN_SOURCES + ${EXAMPLES_DIR}/pythagorian/main.cpp ) -add_executable(testbench ${TESTBENCH_SOURCES}) - -# define the sources of the self test -set(V2_TEST_SOURCES - ${V2_TEST_DIR}/test.cpp - ${V2_TEST_DIR}/operators/buffer.cpp - ${V2_TEST_DIR}/sources/defer.cpp - ${V2_TEST_DIR}/operators/combine_latest.cpp - ${V2_TEST_DIR}/sources/interval.cpp - ${V2_TEST_DIR}/operators/concat.cpp - ${V2_TEST_DIR}/operators/merge.cpp - ${V2_TEST_DIR}/operators/lift.cpp - ${V2_TEST_DIR}/operators/filter.cpp - ${V2_TEST_DIR}/subscriptions/observer.cpp - ${V2_TEST_DIR}/operators/scan.cpp - ${V2_TEST_DIR}/operators/take.cpp - ${V2_TEST_DIR}/operators/publish.cpp - ${V2_TEST_DIR}/subjects/subject.cpp - ${V2_TEST_DIR}/subscriptions/subscription.cpp - ${V2_TEST_DIR}/operators/flat_map.cpp - ${V2_TEST_DIR}/operators/concat_map.cpp - ${V2_TEST_DIR}/operators/map.cpp -) -add_executable(rxcppv2_test ${V2_TEST_SOURCES}) +add_executable(pythagorian ${PYTHAGORIAN_SOURCES}) # configure unit tests via CTest enable_testing() -add_test(NAME RunTests COMMAND rxcpp_test) +add_test(NAME RunTests COMMAND rxcppv2_test) -add_test(NAME ListTests COMMAND rxcpp_test --list-tests) +add_test(NAME ListTests COMMAND rxcppv2_test --list-tests) set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases") -add_test(NAME ListTags COMMAND rxcpp_test --list-tags) +add_test(NAME ListTags COMMAND rxcppv2_test --list-tags) set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags") - -add_test(NAME RunTestsV2 COMMAND rxcppv2_test) - -add_test(NAME ListTestsV2 COMMAND rxcppv2_test --list-tests) -set_tests_properties(ListTestsV2 PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test cases") - -add_test(NAME ListTagsV2 COMMAND rxcppv2_test --list-tags) -set_tests_properties(ListTagsV2 PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags") diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig index 7c002d0..bb3b63e 100644 --- a/projects/nuget/rxcpp.autoconfig +++ b/projects/nuget/rxcpp.autoconfig @@ -21,8 +21,8 @@ nuget { #defines { SDK_RX = ..\..\; } - include: { "${SDK_RX}Rx\CPP\src\**\*", "${SDK_RX}Ix\CPP\src\**\*" }; - docs: { ${SDK_RX}Readme.html, ${SDK_RX}AUTHORS.txt, ${SDK_RX}Rx\CPP\license.txt }; + include: { "${SDK_RX}Rx\v2\src\**\*", "${SDK_RX}Ix\CPP\src\**\*" }; + docs: { ${SDK_RX}Readme.html, ${SDK_RX}AUTHORS.txt, ${SDK_RX}v2\license.txt }; } targets { -- GitLab From 07113b9f2b3ba10d15be42919a28b7eca862e397 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 14:02:50 -0700 Subject: [PATCH 324/782] fix some reported issues --- README.md | 16 ++++++++-------- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 2 +- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 4 ++-- Rx/v2/test/operators/concat.cpp | 2 +- Rx/v2/test/operators/concat_map.cpp | 2 +- Rx/v2/test/operators/merge.cpp | 2 +- Rx/v2/test/sources/interval.cpp | 2 +- Rx/v2/test/subscriptions/subscription.cpp | 6 +++--- 8 files changed, 18 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index 9140c1d..c04513e 100644 --- a/README.md +++ b/README.md @@ -17,10 +17,10 @@ Rxcpp Build status [![Build Status](https://travis-ci.org/Reactive-Extensions/Rx #Building RxCpp -RxCpp is regularly tested on OSX and Windows. -RxCpp is regularly built with Clang and VC -RxCpp depends on the latest compiler releases. -RxCpp does not compile with gcc at this time. Contributions are welcome. +* RxCpp is regularly tested on OSX and Windows. +* RxCpp is regularly built with Clang and VC +* RxCpp depends on the latest compiler releases. +* RxCpp does not compile with gcc at this time. Contributions are welcome. RxCpp uses CMake to create build files for several platforms and IDE's @@ -34,7 +34,7 @@ This will create the default build for the platform. ###Visual Studio 13 ```cmake -G"Visual Studio 12" projects\CMake``` -Then open in VC2013 and upgrade to the 2013 toolset +* Note: open in VC2013 and upgrade to the 2013 toolset ##makefile builds @@ -54,9 +54,9 @@ The build only produces a test binary. #Running tests -You can use the CMake test runner ```ctest``` -You can run the test binary directly ```rxcppv2_test``` -Tests can be selected by name or tag +* You can use the CMake test runner ```ctest``` +* You can run the test binary directly ```rxcppv2_test``` +* Tests can be selected by name or tag Example of by-tag ```rxcppv2_test [perf]``` diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 35b8ed6..1cc72d2 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -79,7 +79,7 @@ static auto interval(rxsc::scheduler::clock_type::time_point initial, Duration p -> typename detail::delay_resolution::type { return observable>( rxs::detail::interval(initial, period, identity_one_worker(rxsc::make_current_thread()))); - static_assert(std::is_same::value, "duration must be rxsc::scheduler::clock_type::duration"); + static_assert(std::is_convertible::value, "duration must be convertible to rxsc::scheduler::clock_type::duration"); } template static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, Coordination cn) diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 7b72cf7..ef3d0b4 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -183,7 +183,7 @@ public: } -class syncronize_in_one_worker : public coordination_base +class synchronize_in_one_worker : public coordination_base { rxsc::scheduler factory; @@ -238,7 +238,7 @@ class syncronize_in_one_worker : public coordination_base public: - explicit syncronize_in_one_worker(rxsc::scheduler sc) : factory(sc) {} + explicit synchronize_in_one_worker(rxsc::scheduler sc) : factory(sc) {} typedef coordinator coordinator_type; diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index aadc1fb..7611430 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -27,7 +27,7 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rx::syncronize_in_one_worker(sc); + auto so = rx::synchronize_in_one_worker(sc); std::atomic c(0); int n = 1; diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index ffe8e85..5bc1411 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -71,7 +71,7 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rx::syncronize_in_one_worker(sc); + auto so = rx::synchronize_in_one_worker(sc); int c = 0; std::atomic ct(0); diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 21f722e..926a347 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -27,7 +27,7 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rx::syncronize_in_one_worker(sc); + auto so = rx::synchronize_in_one_worker(sc); std::atomic c(0); int n = 1; diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp index 7aa621f..63c6503 100644 --- a/Rx/v2/test/sources/interval.cpp +++ b/Rx/v2/test/sources/interval.cpp @@ -87,7 +87,7 @@ SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf]"){ int c = 0; auto sc = rxsc::make_current_thread(); - auto so = rx::syncronize_in_one_worker(sc); + auto so = rx::synchronize_in_one_worker(sc); auto start = sc.now() + seconds(2); auto period = seconds(1); rx::composite_subscription cs; diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 24bf747..18d66b5 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -92,7 +92,7 @@ SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][subscribe][ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf]"){ GIVEN("range"){ - WHEN("syncronized"){ + WHEN("synchronized"){ using namespace std::chrono; typedef steady_clock clock; @@ -100,7 +100,7 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto w = sc.create_worker(); auto el = rxsc::make_event_loop(); - auto es = rx::syncronize_in_one_worker(el); + auto es = rx::synchronize_in_one_worker(el); int runs = 10; @@ -184,7 +184,7 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf s2.unsubscribe(); auto finish = clock::now(); auto msElapsed = duration_cast(finish-start); - std::cout << "range syncronize : " << n << " subscribed, " << v << " on_next calls, " << msElapsed.count() << "ms elapsed, " << v / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + std::cout << "range synchronize : " << n << " subscribed, " << v << " on_next calls, " << msElapsed.count() << "ms elapsed, " << v / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; if (--runs > 0) { self(); -- GitLab From c044f49400561ec2c18006b9dcb5d1ee031af8bc Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 14:03:30 -0700 Subject: [PATCH 325/782] introducing initializer_list --- Rx/v2/src/rxcpp/rx-includes.hpp | 1 + Rx/v2/src/rxcpp/rx-util.hpp | 10 ++-- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 69 ++++++++++++++++++++++---- Rx/v2/test/operators/take.cpp | 45 +++++++---------- 4 files changed, 86 insertions(+), 39 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 6f9d903..28ed62c 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -96,6 +96,7 @@ #include #include #include +#include #include #include "rx-util.hpp" diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 31ec1e3..dd307b2 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -37,10 +37,14 @@ std::vector to_vector(const T (&arr) [size]) { return std::vector(std::begin(arr), std::end(arr)); } +template +std::vector to_vector(std::initializer_list il) { + return std::vector(il); +} + template -typename std::enable_if::value, std::vector>::type to_vector(T0 t0, TN... tn) { - T0 arr[] = {t0, tn...}; - return to_vector(arr); +typename std::enable_if::value && std::is_pod::value, std::vector>::type to_vector(T0 t0, TN... tn) { + return to_vector({t0, tn...}); } template diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 9f01ab7..336cf1b 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -338,6 +338,18 @@ rxt::testable_observable test_type::make_hot_observable(std::vector>(state, create_worker(composite_subscription()), std::move(messages))); } +template +struct is_create_source_function +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CF*)nullptr)()); + template + static not_void check(...); + + static const bool value = is_observable::type>(0))>::value; +}; + } class test : public scheduler @@ -362,6 +374,9 @@ public: { typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; + typedef rxn::subscription subscription_type; + + messages() {} struct on_next_factory { @@ -394,9 +409,6 @@ public: } }; static const subscribe_factory subscribe; - - private: - ~messages(); }; class test_worker : public worker @@ -440,15 +452,13 @@ public: } template - auto start(F&& createSource, long created, long subscribed, long unsubscribed) const + auto start(F createSource, long created, long subscribed, long unsubscribed) const -> subscriber> { - typename std::decay::type createSrc = std::forward(createSource); - struct state_type : public std::enable_shared_from_this { - typedef decltype(std::forward(createSrc)()) source_type; + typedef decltype(createSource()) source_type; std::unique_ptr source; subscriber> o; @@ -461,8 +471,8 @@ public: }; std::shared_ptr state(new state_type(this->make_subscriber())); - schedule_absolute(created, [createSrc, state](const schedulable& scbl) { - state->source.reset(new typename state_type::source_type(createSrc())); + schedule_absolute(created, [createSource, state](const schedulable& scbl) { + state->source.reset(new typename state_type::source_type(createSource())); }); schedule_absolute(subscribed, [state](const schedulable& scbl) { state->source->subscribe(state->o); @@ -490,6 +500,35 @@ public: return start(std::forward(createSource), created_time, subscribed_time, unsubscribed_time); } + template + struct start_traits + { + typedef decltype((*(F*)nullptr)()) source_type; + typedef typename source_type::value_type value_type; + typedef subscriber> subscriber_type; + }; + + template + auto start(F createSource, long created, long subscribed, long unsubscribed) const + -> typename std::enable_if::value, start_traits>::type::subscriber_type + { + return start::value_type>(std::move(createSource), created, subscribed, unsubscribed); + } + + template + auto start(F createSource, long unsubscribed) const + -> typename std::enable_if::value, start_traits>::type::subscriber_type + { + return start::value_type>(std::move(createSource), created_time, subscribed_time, unsubscribed); + } + + template + auto start(F createSource) const + -> typename std::enable_if::value, start_traits>::type::subscriber_type + { + return start::value_type>(std::move(createSource), created_time, subscribed_time, unsubscribed_time); + } + void start() const { tester->start(); } @@ -522,6 +561,12 @@ public: return tester->make_hot_observable(rxu::to_vector(arr)); } + template + auto make_hot_observable(std::initializer_list il) const + -> decltype(tester->make_hot_observable(std::vector())) { + return tester->make_hot_observable(std::vector(il)); + } + template rxt::testable_observable make_cold_observable(std::vector>>> messages) const { return tester->make_cold_observable(std::move(messages)); @@ -532,6 +577,12 @@ public: -> decltype(tester->make_cold_observable(std::vector())) { return tester->make_cold_observable(rxu::to_vector(arr)); } + + template + auto make_cold_observable(std::initializer_list il) const + -> decltype(tester->make_cold_observable(std::vector())) { + return tester->make_cold_observable(std::vector(il)); + } }; template diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index e44bd5b..26582f1 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -16,27 +16,20 @@ SCENARIO("take 2", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; - record xmessages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto xs = sc.make_hot_observable(xmessages); + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); WHEN("2 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(2) @@ -46,21 +39,19 @@ SCENARIO("take 2", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 2), - on_next(220, 3), - on_completed(220) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_completed(220) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 220) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } -- GitLab From c81d5f5053057ba971a36a3afe7f0f1e6aea1fcc Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 14:26:06 -0700 Subject: [PATCH 326/782] make travis build on osx --- .travis.yml | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 65065ce..8e04084 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ compiler: - clang env: - - BUILD_TYPE=Debug + - BUILD_TYPE=RelWithDebInfo - BUILD_TYPE=Release install: @@ -16,3 +16,16 @@ install: script: - cd Build - ctest -V + +branches: + only: + - master +notifications: + recipients: + - kirk.shoop@microsoft.com + email: + on_success: change + on_failure: always + +os: + - osx -- GitLab From c5205c6931527ed105ce9b7679c05de0816afd4c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 14:34:32 -0700 Subject: [PATCH 327/782] force libc++ for clang --- projects/CMake/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 34ab78d..304c901 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -5,7 +5,7 @@ project(rxcpp) MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - list( APPEND CMAKE_CXX_FLAGS " -std=c++0x ${CMAKE_CXX_FLAGS}") + list( APPEND CMAKE_CXX_FLAGS " -std=c++11 -stdlib=libc++ ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") list( APPEND CMAKE_CXX_FLAGS " -std=c++0x ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") -- GitLab From ee21e59cd2edadaf3510212d0219f571f49853e1 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 14:54:57 -0700 Subject: [PATCH 328/782] ask travis to build and install libc++ --- .travis.yml | 7 +++++++ projects/CMake/CMakeLists.txt | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 8e04084..cf189e8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,6 +8,13 @@ env: - BUILD_TYPE=Release install: + - if [ "$CXX" == "clang++" ]; then svn co --quiet http://llvm.org/svn/llvm-project/libcxx/trunk libcxx; fi + - if [ "$CXX" == "clang++" ]; then cd libcxx/lib && bash buildit; fi + - if [ "$CXX" == "clang++" ]; then sudo cp ./libc++.so.1.0 /usr/lib/; fi + - if [ "$CXX" == "clang++" ]; then sudo mkdir /usr/include/c++/v1; fi + - if [ "$CXX" == "clang++" ]; then cd .. && sudo cp -r include/* /usr/include/c++/v1/; fi + - if [ "$CXX" == "clang++" ]; then cd /usr/lib && sudo ln -sf libc++.so.1.0 libc++.so; fi + - if [ "$CXX" == "clang++" ]; then sudo ln -sf libc++.so.1.0 libc++.so.1 && cd $cwd; fi - cmake -Hprojects/CMake -BBuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE - cd Build - make diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 304c901..61e9514 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -7,7 +7,7 @@ MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") list( APPEND CMAKE_CXX_FLAGS " -std=c++11 -stdlib=libc++ ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - list( APPEND CMAKE_CXX_FLAGS " -std=c++0x ${CMAKE_CXX_FLAGS}") + list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") list( APPEND CMAKE_CXX_FLAGS " /DUNICODE /D_UNICODE /bigobj ${CMAKE_CXX_FLAGS}") endif() -- GitLab From 3fe727d5d942646c37897247aa9ba1b442e1531d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 15:47:35 -0700 Subject: [PATCH 329/782] try Xcode build --- .travis.yml | 14 +++++--------- projects/CMake/CMakeLists.txt | 2 +- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/.travis.yml b/.travis.yml index cf189e8..7af6eb0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,21 +8,17 @@ env: - BUILD_TYPE=Release install: - - if [ "$CXX" == "clang++" ]; then svn co --quiet http://llvm.org/svn/llvm-project/libcxx/trunk libcxx; fi - - if [ "$CXX" == "clang++" ]; then cd libcxx/lib && bash buildit; fi - - if [ "$CXX" == "clang++" ]; then sudo cp ./libc++.so.1.0 /usr/lib/; fi - - if [ "$CXX" == "clang++" ]; then sudo mkdir /usr/include/c++/v1; fi - - if [ "$CXX" == "clang++" ]; then cd .. && sudo cp -r include/* /usr/include/c++/v1/; fi - - if [ "$CXX" == "clang++" ]; then cd /usr/lib && sudo ln -sf libc++.so.1.0 libc++.so; fi - - if [ "$CXX" == "clang++" ]; then sudo ln -sf libc++.so.1.0 libc++.so.1 && cd $cwd; fi - - cmake -Hprojects/CMake -BBuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE + - brew update + - brew install cmake + - cmake -GXcode -Hprojects/CMake -BBuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE - cd Build - - make + - xcodebuild - cd .. script: - cd Build - ctest -V + - cd .. branches: only: diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 61e9514..7135acc 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -5,7 +5,7 @@ project(rxcpp) MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - list( APPEND CMAKE_CXX_FLAGS " -std=c++11 -stdlib=libc++ ${CMAKE_CXX_FLAGS}") + list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") -- GitLab From 82d0388aee7556b80fd1e23fac74f13d2deac593 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 18:01:18 -0700 Subject: [PATCH 330/782] try to install Xcode command line tools --- .travis.yml | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 7af6eb0..97650f6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,10 +10,12 @@ env: install: - brew update - brew install cmake - - cmake -GXcode -Hprojects/CMake -BBuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE - - cd Build - - xcodebuild - - cd .. + - xcode-select --install + - cd projects + - cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE + - cd build + - make -j4 + - cd ../.. script: - cd Build -- GitLab From 4e7c1ea6c094395fc766d8b24a10bdc988a28447 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 18:06:09 -0700 Subject: [PATCH 331/782] brew update failed? --- .travis.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 97650f6..d9daf0a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,10 +7,12 @@ env: - BUILD_TYPE=RelWithDebInfo - BUILD_TYPE=Release -install: +before_install: + - xcode-select --install - brew update - brew install cmake - - xcode-select --install + +install: - cd projects - cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE - cd build -- GitLab From 6920e384293913ac74b00142579fc3bc4e51c007 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 23:18:08 -0700 Subject: [PATCH 332/782] try clang on linux --- .travis.yml | 15 ++++++++------- projects/CMake/CMakeLists.txt | 5 +++++ 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/.travis.yml b/.travis.yml index d9daf0a..51435aa 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,5 +1,10 @@ + language: cpp +os: + - linux + - osx + compiler: - clang @@ -8,9 +13,7 @@ env: - BUILD_TYPE=Release before_install: - - xcode-select --install - - brew update - - brew install cmake + - sh projects/scripts/travis-install.sh install: - cd projects @@ -20,19 +23,17 @@ install: - cd ../.. script: - - cd Build + - cd projects/build - ctest -V - cd .. branches: only: - master + notifications: recipients: - kirk.shoop@microsoft.com email: on_success: change on_failure: always - -os: - - osx diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 7135acc..211c517 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -4,6 +4,8 @@ project(rxcpp) MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) +FIND_PACKAGE(Threads) + if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") @@ -12,6 +14,7 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") list( APPEND CMAKE_CXX_FLAGS " /DUNICODE /D_UNICODE /bigobj ${CMAKE_CXX_FLAGS}") endif() + # define some folders get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) @@ -43,12 +46,14 @@ set(TEST_SOURCES ${TEST_DIR}/operators/map.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) +TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) # define the sources of the pythagorian example set(PYTHAGORIAN_SOURCES ${EXAMPLES_DIR}/pythagorian/main.cpp ) add_executable(pythagorian ${PYTHAGORIAN_SOURCES}) +TARGET_LINK_LIBRARIES(pythagorian ${CMAKE_THREAD_LIBS_INIT}) # configure unit tests via CTest enable_testing() -- GitLab From 9ee3732d132a35d8afc1e0951ab70651f754d789 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 23:20:22 -0700 Subject: [PATCH 333/782] add missing script --- projects/scripts/travis-install.sh | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 projects/scripts/travis-install.sh diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh new file mode 100644 index 0000000..ef5bb42 --- /dev/null +++ b/projects/scripts/travis-install.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +set -e + +#if OS is linux or is not set +if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then + sudo apt-get update + sudo apt-get install -qq libc++ + sudo apt-get install cmake clang-3.5 libstdc++6 + sudo apt-get autoremove +elif [ "$TRAVIS_OS_NAME" = osx ]; then + xcode-select --install + brew update + brew install cmake +fi -- GitLab From ab4acc45d348a771956b6f11775ae1428f5c9014 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 23:27:59 -0700 Subject: [PATCH 334/782] add apt-get clean --- projects/scripts/travis-install.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index ef5bb42..65a8baa 100644 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -4,6 +4,7 @@ set -e #if OS is linux or is not set if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then + sudo apt-get clean sudo apt-get update sudo apt-get install -qq libc++ sudo apt-get install cmake clang-3.5 libstdc++6 -- GitLab From 90216c457e0bacb6a4b6910e4f9e68f7249dee3e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 23:33:09 -0700 Subject: [PATCH 335/782] trying a solution from the web --- projects/scripts/travis-install.sh | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 65a8baa..cb84aa4 100644 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -4,11 +4,15 @@ set -e #if OS is linux or is not set if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then + wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key|sudo apt-key add - + sudo add-apt-repository -y 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise main' + sudo add-apt-repository -y ppa:28msec/utils # Recent cmake + sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang-3.5 sudo apt-get clean sudo apt-get update - sudo apt-get install -qq libc++ - sudo apt-get install cmake clang-3.5 libstdc++6 - sudo apt-get autoremove + sudo apt-get install -q --fix-missing clang-3.5 cmake libssl-dev +#libstdc++6 + elif [ "$TRAVIS_OS_NAME" = osx ]; then xcode-select --install brew update -- GitLab From 20ec8c1cbf81acc8b3b5b949673d7ac9c8a27f05 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 13 Jun 2014 23:40:42 -0700 Subject: [PATCH 336/782] updated build steps --- README.md | 40 ++++++++++++++++++++++++---------------- 1 file changed, 24 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index c04513e..9ab9eb2 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ -# Reactive Extensions: +[![Build Status](https://travis-ci.org/Reactive-Extensions/RxCpp.png)](https://travis-ci.org/Reactive-Extensions/RxCpp) -Rxcpp Build status [![Build Status](https://travis-ci.org/Reactive-Extensions/RxCpp.png)](https://travis-ci.org/Reactive-Extensions/RxCpp) +# Reactive Extensions: * Rx.NET: The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. * RxJS: The Reactive Extensions for JavaScript (RxJS) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in JavaScript which can target both the browser and Node.js. @@ -24,29 +24,37 @@ Rxcpp Build status [![Build Status](https://travis-ci.org/Reactive-Extensions/Rx RxCpp uses CMake to create build files for several platforms and IDE's -```cmake projects\CMake``` - -This will create the default build for the platform. - -##Ide builds -###XCode -```cmake -G"Xcode" projects\CMake``` +###Ide builds +####XCode +``` +mkdir projects/build +cd projects/build +cmake -G"Xcode" ../CMake -B. +``` -###Visual Studio 13 -```cmake -G"Visual Studio 12" projects\CMake``` +####Visual Studio 13 +``` +mkdir projects\build +cd projects\build +cmake -G"Visual Studio 12" ..\CMake -B. +``` * Note: open in VC2013 and upgrade to the 2013 toolset -##makefile builds +###makefile builds -##OSX +####OSX ``` -cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo projects\CMake +mkdir projects/build +cd projects/build +cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake make ``` -##Windows +####Windows ``` -cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo projects\CMake +mkdir projects\build +cd projects\build +cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ..\CMake nmake ``` -- GitLab From 71b97f68fa64006f91ea4133a9fadb76b1daf14a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 15 Jun 2014 09:31:08 -0700 Subject: [PATCH 337/782] add distinct_until_changed --- .../operators/rx-distinct_until_changed.hpp | 82 +++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 8 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + .../test/operators/distinct_until_changed.cpp | 64 +++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 5 files changed, 156 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp create mode 100644 Rx/v2/test/operators/distinct_until_changed.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp new file mode 100644 index 0000000..52954f5 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp @@ -0,0 +1,82 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_DISTINCT_UNTIL_CHANGED_HPP) +#define RXCPP_OPERATORS_RX_DISTINCT_UNTIL_CHANGED_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct distinct_until_changed +{ + typedef typename std::decay::type source_value_type; + + template + struct distinct_until_changed_observer : public observer_base + { + typedef distinct_until_changed_observer this_type; + typedef observer_base base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + mutable rxu::detail::maybe remembered; + + distinct_until_changed_observer(dest_type d) + : dest(d) + { + } + void on_next(source_value_type v) const { + if (remembered.empty() || v != remembered.get()) { + remembered.reset(v); + dest.on_next(v); + } + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_completed(); + } + + static subscriber make(dest_type d) { + return make_subscriber(d, this_type(d)); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(distinct_until_changed_observer::make(std::move(dest))) { + return distinct_until_changed_observer::make(std::move(dest)); + } +}; + +class distinct_until_changed_factory +{ +public: + template + auto operator()(Observable&& source) + -> decltype(source.lift(distinct_until_changed::type>::value_type)) { + return source.lift(distinct_until_changed::type>::value_type); + } +}; + +} + +inline auto distinct_until_changed() + -> detail::distinct_until_changed_factory { + return detail::distinct_until_changed_factory(); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index f14c0ac..caeb876 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -325,6 +325,14 @@ public: return lift(rxo::detail::map(std::move(s))); } + /// distinct_until_changed -> + /// for each item from this observable, filter out repeated values and emit only changes from the new observable that is returned. + /// + auto distinct_until_changed() const + -> decltype(lift(rxo::detail::distinct_until_changed())) { + return lift(rxo::detail::distinct_until_changed()); + } + /// buffer -> /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 4928940..b535e17 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -38,6 +38,7 @@ namespace rxo=operators; #include "operators/rx-buffer_count.hpp" #include "operators/rx-subscribe.hpp" #include "operators/rx-filter.hpp" +#include "operators/rx-distinct_until_changed.hpp" #include "operators/rx-map.hpp" #include "operators/rx-merge.hpp" #include "operators/rx-flat_map.hpp" diff --git a/Rx/v2/test/operators/distinct_until_changed.cpp b/Rx/v2/test/operators/distinct_until_changed.cpp new file mode 100644 index 0000000..2639574 --- /dev/null +++ b/Rx/v2/test/operators/distinct_until_changed.cpp @@ -0,0 +1,64 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("distinct_until_changed - some changes", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), //* + on.on_next(215, 3), //* + on.on_next(220, 3), + on.on_next(225, 2), //* + on.on_next(230, 2), + on.on_next(230, 1), //* + on.on_next(240, 2), //* + on.on_completed(250) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), //* + on.on_next(215, 3), //* + on.on_next(225, 2), //* + on.on_next(230, 1), //* + on.on_next(240, 2), //* + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 211c517..652df5e 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -38,6 +38,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/merge.cpp ${TEST_DIR}/operators/lift.cpp ${TEST_DIR}/operators/filter.cpp + ${TEST_DIR}/operators/distinct_until_changed.cpp ${TEST_DIR}/operators/scan.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/publish.cpp -- GitLab From 91150a059f5250238ec264a888f7f9782ff4cf01 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 15 Jun 2014 23:07:40 -0700 Subject: [PATCH 338/782] coordinator refinements --- .../src/rxcpp/operators/rx-combine_latest.hpp | 19 +- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 28 +-- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 29 ++-- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 33 ++-- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 28 +-- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 17 +- Rx/v2/src/rxcpp/rx-coordination.hpp | 162 +++++++++++++++--- Rx/v2/src/rxcpp/sources/rx-error.hpp | 9 +- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 13 +- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 10 +- Rx/v2/src/rxcpp/sources/rx-range.hpp | 12 +- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 36 ++-- Rx/v2/test/operators/concat.cpp | 41 +++++ Rx/v2/test/operators/concat_map.cpp | 65 ++++++- Rx/v2/test/operators/flat_map.cpp | 69 +++++++- Rx/v2/test/operators/merge.cpp | 42 +++++ Rx/v2/test/subscriptions/subscription.cpp | 2 +- projects/CMake/CMakeLists.txt | 9 +- 18 files changed, 473 insertions(+), 151 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index f990dc7..61d0d47 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -89,7 +89,7 @@ struct combine_latest : public operator_basesubscribe( + auto sink = make_subscriber( state->out, innercs, // on_next @@ -126,6 +126,13 @@ struct combine_latest : public operator_basecoordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + source->subscribe(std::move(selectedSink.get())); } template void subscribe_all(std::shared_ptr state, rxu::values) const { @@ -136,7 +143,7 @@ struct combine_latest : public operator_base::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; + typedef Subscriber output_type; struct combine_latest_state_type : public std::enable_shared_from_this @@ -161,15 +168,9 @@ struct combine_latest : public operator_base(new combine_latest_state_type(initial, std::move(coordinator), std::forward(selectedDest.get()))); + auto state = std::shared_ptr(new combine_latest_state_type(initial, std::move(coordinator), std::move(scbr))); subscribe_all(state, typename rxu::values_from::type()); } diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index 57f7143..68179be 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -48,7 +48,7 @@ struct concat void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; + typedef Subscriber output_type; struct concat_state_type : public std::enable_shared_from_this @@ -86,7 +86,7 @@ struct concat // this subscribe does not share the out subscription // so that when it is unsubscribed the out will continue - selectedSource->subscribe( + auto sinkInner = make_subscriber( state->out, collectionLifetime, // on_next @@ -109,6 +109,13 @@ struct concat } } ); + auto selectedSinkInner = on_exception( + [&](){return state->coordinator.out(sinkInner);}, + state->out); + if (selectedSinkInner.empty()) { + return; + } + selectedSource->subscribe(std::move(selectedSinkInner.get())); } composite_subscription sourceLifetime; composite_subscription collectionLifetime; @@ -118,15 +125,9 @@ struct concat }; auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); - auto selectedDest = on_exception( - [&](){return coordinator.out(scbr);}, - scbr); - if (selectedDest.empty()) { - return; - } // take a copy of the values for each subscription - auto state = std::shared_ptr(new concat_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); + auto state = std::shared_ptr(new concat_state_type(initial, std::move(coordinator), std::move(scbr))); state->sourceLifetime = composite_subscription(); @@ -144,7 +145,7 @@ struct concat // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - source->subscribe( + auto sink = make_subscriber( state->out, state->sourceLifetime, // on_next @@ -166,6 +167,13 @@ struct concat } } ); + auto selectedSink = on_exception( + [&](){return state->coordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + source->subscribe(std::move(selectedSink.get())); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 922d5a2..a1f9061 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -91,7 +91,7 @@ struct concat_map void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; + typedef Subscriber output_type; struct concat_map_state_type : public std::enable_shared_from_this @@ -136,7 +136,7 @@ struct concat_map // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue - selectedSource->subscribe( + auto sinkInner = make_subscriber( state->out, collectionLifetime, // on_next @@ -165,6 +165,13 @@ struct concat_map } } ); + auto selectedSinkInner = on_exception( + [&](){return state->coordinator.out(sinkInner);}, + state->out); + if (selectedSinkInner.empty()) { + return; + } + selectedSource->subscribe(std::move(selectedSinkInner.get())); } composite_subscription sourceLifetime; composite_subscription collectionLifetime; @@ -174,15 +181,9 @@ struct concat_map }; auto coordinator = initial.coordination.create_coordinator(); - auto selectedDest = on_exception( - [&](){return coordinator.out(scbr);}, - scbr); - if (selectedDest.empty()) { - return; - } // take a copy of the values for each subscription - auto state = std::shared_ptr(new concat_map_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); + auto state = std::shared_ptr(new concat_map_state_type(initial, std::move(coordinator), std::move(scbr))); state->sourceLifetime = composite_subscription(); @@ -200,7 +201,7 @@ struct concat_map // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - source->subscribe( + auto sink = make_subscriber( state->out, state->sourceLifetime, // on_next @@ -222,6 +223,14 @@ struct concat_map } } ); + auto selectedSink = on_exception( + [&](){return state->coordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + source->subscribe(std::move(selectedSink.get())); + } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index d09caf9..1906724 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -91,7 +91,7 @@ struct flat_map void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; + typedef Subscriber output_type; struct state_type : public std::enable_shared_from_this @@ -112,15 +112,9 @@ struct flat_map }; auto coordinator = initial.coordination.create_coordinator(); - auto selectedDest = on_exception( - [&](){return coordinator.out(scbr);}, - scbr); - if (selectedDest.empty()) { - return; - } // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); + auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(scbr))); composite_subscription outercs; @@ -139,7 +133,7 @@ struct flat_map // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - source->subscribe( + auto sink = make_subscriber( state->out, outercs, // on_next @@ -171,7 +165,7 @@ struct flat_map ++state->pendingCompletions; // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue - selectedSource->subscribe( + auto sinkInner = make_subscriber( state->out, innercs, // on_next @@ -195,6 +189,15 @@ struct flat_map } } ); + + auto selectedSinkInner = on_exception( + [&](){return state->coordinator.out(sinkInner);}, + state->out); + if (selectedSinkInner.empty()) { + return; + } + + selectedSource->subscribe(std::move(selectedSinkInner.get())); }, // on_error [state](std::exception_ptr e) { @@ -207,6 +210,16 @@ struct flat_map } } ); + + auto selectedSink = on_exception( + [&](){return state->coordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + + source->subscribe(std::move(selectedSink.get())); + } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index e2b5d14..5eddc15 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -45,7 +45,7 @@ struct merge : public operator_base::type::value void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; + typedef Subscriber output_type; struct merge_state_type : public std::enable_shared_from_this @@ -66,15 +66,9 @@ struct merge : public operator_base::type::value }; auto coordinator = initial.coordination.create_coordinator(); - auto selectedDest = on_exception( - [&](){return coordinator.out(scbr);}, - scbr); - if (selectedDest.empty()) { - return; - } // take a copy of the values for each subscription - auto state = std::shared_ptr(new merge_state_type(initial, std::move(coordinator), std::forward(selectedDest.get()))); + auto state = std::shared_ptr(new merge_state_type(initial, std::move(coordinator), std::move(scbr))); composite_subscription outercs; @@ -93,7 +87,7 @@ struct merge : public operator_base::type::value // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished - source->subscribe( + auto sink = make_subscriber( state->out, outercs, // on_next @@ -119,7 +113,7 @@ struct merge : public operator_base::type::value ++state->pendingCompletions; // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue - selectedSource->subscribe( + auto sinkInner = make_subscriber( state->out, innercs, // on_next @@ -137,6 +131,13 @@ struct merge : public operator_base::type::value } } ); + auto selectedSinkInner = on_exception( + [&](){return state->coordinator.out(sinkInner);}, + state->out); + if (selectedSinkInner.empty()) { + return; + } + selectedSource->subscribe(std::move(selectedSinkInner.get())); }, // on_error [state](std::exception_ptr e) { @@ -149,6 +150,13 @@ struct merge : public operator_base::type::value } } ); + auto selectedSink = on_exception( + [&](){return state->coordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + source->subscribe(std::move(selectedSink.get())); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index c5f2576..00dc952 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -75,15 +75,9 @@ struct take_until : public operator_base }; auto coordinator = initial.coordination.create_coordinator(); - auto selectedDest = on_exception( - [&](){return coordinator.out(s);}, - s); - if (selectedDest.empty()) { - return; - } // take a copy of the values for each subscription - auto state = std::shared_ptr(new take_until_state_type(initial, std::move(coordinator), std::move(selectedDest.get()))); + auto state = std::shared_ptr(new take_until_state_type(initial, std::move(coordinator), std::move(s))); auto trigger = on_exception( [&](){return state->coordinator.in(state->trigger);}, @@ -99,7 +93,7 @@ struct take_until : public operator_base return; } - trigger.get().subscribe( + auto sinkTrigger = make_subscriber( // share parts of subscription state->out, // new lifetime @@ -122,6 +116,13 @@ struct take_until : public operator_base state->mode_value = mode::clear; } ); + auto selectedSinkTrigger = on_exception( + [&](){return state->coordinator.out(sinkTrigger);}, + state->out); + if (selectedSinkTrigger.empty()) { + return; + } + trigger->subscribe(std::move(selectedSinkTrigger.get())); source.get().subscribe( // split subscription lifetime diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index 880fc5c..39cd134 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -35,60 +35,74 @@ public: static const bool value = std::is_convertible::type>(0)), tag_coordination*>::value; }; -template +template class coordinator : public coordinator_base { - struct not_supported {typedef not_supported type;}; public: typedef Input input_type; - typedef Output output_type; - input_type input; - output_type output; +private: + struct not_supported {typedef not_supported type;}; template struct get_observable { - typedef decltype((*(input_type*)nullptr)((*(Observable*)nullptr))) type; + typedef decltype((*(input_type*)nullptr).in((*(Observable*)nullptr))) type; }; template struct get_subscriber { - typedef decltype((*(output_type*)nullptr)((*(Subscriber*)nullptr))) type; + typedef decltype((*(input_type*)nullptr).out((*(Subscriber*)nullptr))) type; }; + template + struct get_action_function + { + typedef decltype((*(input_type*)nullptr).act((*(F*)nullptr))) type; + }; + +public: + input_type input; + template struct get { typedef typename std::conditional< + rxsc::detail::is_action_function::value, get_action_function, typename std::conditional< is_observable::value, get_observable, typename std::conditional< - is_subscriber::value, get_subscriber, not_supported>::type>::type::type type; + is_subscriber::value, get_subscriber, not_supported>::type>::type>::type::type type; }; - coordinator(Input i, Output o) : input(i), output(o) {} + coordinator(Input i) : input(i) {} - const Input& get_input() const { - return input; + rxsc::worker get_worker() const { + return input.get_worker(); } - - const Output& get_output() const { - return output; + rxsc::scheduler get_scheduler() const { + return input.get_scheduler(); } template auto in(Observable o) const -> typename get_observable::type { - return input(std::move(o)); + return input.in(std::move(o)); static_assert(is_observable::value, "can only synchronize observables"); } template auto out(Subscriber s) const -> typename get_subscriber::type { - return output(std::move(s)); + return input.out(std::move(s)); static_assert(is_subscriber::value, "can only synchronize subscribers"); } + + template + auto act(F f) const + -> typename get_action_function::type { + return input.act(std::move(f)); + static_assert(rxsc::detail::is_action_function::value, "can only synchronize action functions"); + } }; class identity_one_worker : public coordination_base @@ -112,20 +126,105 @@ class identity_one_worker : public coordination_base return factory; } template - Observable operator()(Observable o) const { + auto in(Observable o) const + -> Observable { return std::move(o); - static_assert(is_observable::value, "can only synchronize observables"); + } + template + auto out(Subscriber s) const + -> Subscriber { + return std::move(s); + } + template + auto act(F f) const + -> F { + return std::move(f); + } + }; + +public: + + explicit identity_one_worker(rxsc::scheduler sc) : factory(sc) {} + + typedef coordinator coordinator_type; + + coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + auto w = factory.create_worker(std::move(cs)); + return coordinator_type(input_type(std::move(w))); + } +}; + +class serialize_one_worker : public coordination_base +{ + rxsc::scheduler factory; + + template + struct serialize_action + { + F dest; + std::shared_ptr lock; + serialize_action(F d, std::shared_ptr m) + : dest(std::move(d)) + , lock(std::move(m)) + { + if (!lock) { + abort(); + } + } + auto operator()(const rxsc::schedulable& scbl) const + -> decltype(dest(scbl)) { + std::unique_lock guard(*lock); + return dest(scbl); } }; - class output_type + template + struct serialize_observer : public observer_base + { + typedef serialize_observer this_type; + typedef observer_base base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + std::shared_ptr lock; + + serialize_observer(dest_type d, std::shared_ptr m) + : dest(std::move(d)) + , lock(std::move(m)) + { + if (!lock) { + abort(); + } + } + void on_next(value_type v) const { + std::unique_lock guard(*lock); + dest.on_next(v); + } + void on_error(std::exception_ptr e) const { + std::unique_lock guard(*lock); + dest.on_error(e); + } + void on_completed() const { + std::unique_lock guard(*lock); + dest.on_completed(); + } + + static subscriber make(dest_type d, std::shared_ptr m) { + return make_subscriber(d, this_type(d, std::move(m))); + } + }; + + class input_type { rxsc::worker controller; rxsc::scheduler factory; + std::shared_ptr lock; public: - explicit output_type(rxsc::worker w) + explicit input_type(rxsc::worker w, std::shared_ptr m) : controller(w) , factory(rxsc::make_same_worker(w)) + , lock(std::move(m)) { } rxsc::worker get_worker() const { @@ -134,22 +233,33 @@ class identity_one_worker : public coordination_base rxsc::scheduler get_scheduler() const { return factory; } + template + auto in(Observable o) const + -> Observable { + return std::move(o); + } template - Subscriber operator()(Subscriber s) const { - return std::move(s); - static_assert(is_subscriber::value, "can only synchronize subscribers"); + auto out(Subscriber s) const + -> serialize_observer { + return serialize_observer(std::move(s), lock); + } + template + auto act(F f) const + -> serialize_action { + return serialize_action(std::move(f), lock); } }; public: - explicit identity_one_worker(rxsc::scheduler sc) : factory(sc) {} + explicit serialize_one_worker(rxsc::scheduler sc) : factory(sc) {} - typedef coordinator coordinator_type; + typedef coordinator coordinator_type; coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { auto w = factory.create_worker(std::move(cs)); - return coordinator_type(input_type(w), output_type(w)); + std::shared_ptr lock = std::make_shared(); + return coordinator_type(input_type(std::move(w), std::move(lock))); } }; diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index 0c2f67c..439f01a 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -47,16 +47,9 @@ struct error : public source_base auto controller = coordinator.get_output().get_worker(); auto exception = initial.exception; - auto selectedDest = on_exception( - [&](){return coordinator.out(o);}, - o); - if (selectedDest.empty()) { - return; - } - controller.schedule( [=](const rxsc::schedulable&){ - auto& dest = selectedDest.get(); + auto& dest = o; if (!dest.is_subscribed()) { // terminate loop return; diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 1cc72d2..7916359 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -48,21 +48,16 @@ struct interval : public source_base // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); - auto selectedDest = on_exception( - [&](){return coordinator.out(o);}, - o); - if (selectedDest.empty()) { - return; - } + auto controller = coordinator.get_worker(); auto counter = std::make_shared(0); - coordinator.get_output().get_worker().schedule_periodically( + controller.schedule_periodically( initial.initial, initial.period, - [selectedDest, counter](const rxsc::schedulable&) { + [o, counter](const rxsc::schedulable&) { // send next value - selectedDest.get().on_next(++(*counter)); + o.on_next(++(*counter)); }); } }; diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index d3c97b5..a013488 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -93,16 +93,10 @@ struct iterate : public source_base::value_t // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); - auto selectedDest = on_exception( - [&](){return coordinator.out(o);}, - o); - if (selectedDest.empty()) { - return; - } - iterate_state_type state(initial, std::move(selectedDest.get())); + iterate_state_type state(initial, std::move(o)); - auto controller = coordinator.get_output().get_worker(); + auto controller = coordinator.get_worker(); controller.schedule( [state](const rxsc::schedulable& self){ diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index cf82950..f304d6f 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -42,24 +42,18 @@ struct range : public source_base void on_subscribe(Subscriber o) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; + typedef Subscriber output_type; // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); - auto selectedDest = on_exception( - [&](){return coordinator.out(o);}, - o); - if (selectedDest.empty()) { - return; - } - auto controller = coordinator.get_output().get_worker(); + auto controller = coordinator.get_worker(); auto state = initial; controller.schedule( [=](const rxsc::schedulable& self){ - auto& dest = selectedDest.get(); + auto& dest = o; if (!dest.is_subscribed()) { // terminate loop return; diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index ef3d0b4..fce04ac 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -55,7 +55,7 @@ class synchronize_observer : public detail::multicast_observer if (current == mode::Empty) { current = mode::Processing; auto keepAlive = this->shared_from_this(); - auto processor = coordinator.get_output().get_worker(); + auto processor = coordinator.get_worker(); processor.schedule(lifetime, [keepAlive, this](const rxsc::schedulable& self){ try { std::unique_lock guard(lock); @@ -206,33 +206,19 @@ class synchronize_in_one_worker : public coordination_base return factory; } template - auto operator()(Observable o) const + auto in(Observable o) const -> decltype(o.synchronize(coordination).ref_count()) { return o.synchronize(coordination).ref_count(); - static_assert(is_observable::value, "can only synchronize observables"); - } - }; - - class output_type - { - rxsc::worker controller; - rxsc::scheduler factory; - public: - explicit output_type(rxsc::worker w) - : controller(w) - , factory(rxsc::make_same_worker(w)) - { - } - rxsc::worker get_worker() const { - return controller; - } - rxsc::scheduler get_scheduler() const { - return factory; } template - Subscriber operator()(Subscriber s) const { + auto out(Subscriber s) const + -> Subscriber { return std::move(s); - static_assert(is_subscriber::value, "can only synchronize subscribers"); + } + template + auto act(F f) const + -> F { + return std::move(f); } }; @@ -240,11 +226,11 @@ public: explicit synchronize_in_one_worker(rxsc::scheduler sc) : factory(sc) {} - typedef coordinator coordinator_type; + typedef coordinator coordinator_type; coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { auto w = factory.create_worker(std::move(cs)); - return coordinator_type(input_type(w), output_type(w)); + return coordinator_type(input_type(std::move(w))); } }; diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 7611430..244d681 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -56,6 +56,47 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" } } +SCENARIO("serialize concat ranges", "[hide][range][serialize][concat][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("some ranges"){ + WHEN("generating ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rx::serialize_one_worker(sc); + + std::atomic c(0); + int n = 1; + auto sectionCount = onnextcalls / 3; + auto start = clock::now(); + rxs::range(0, sectionCount - 1, 1, so) + .concat( + so, + rxs::range(sectionCount, sectionCount * 2 - 1, 1, so), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) + .subscribe( + [&c](int x){ + ++c;}, + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return c == onnextcalls;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat serial ranges : " << n << " subscribed, " << c << " emitted, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + SCENARIO("concat completes", "[concat][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 5bc1411..f04e0cc 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -53,7 +53,7 @@ SCENARIO("concat_map pythagorian ranges", "[hide][range][concat_map][pythagorian auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "concat pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "concat pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; } } @@ -115,7 +115,68 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "concat sync pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "concat sync pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + } + } +} + +SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][serialize][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rx::serialize_one_worker(sc); + + int c = 0; + std::atomic ct(0); + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, so) + .concat_map( + [&c, so](int z){ + return rxs::range(1, z, 1, so) + .concat_map( + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) + .filter([&c, z, x](int y){ + ++c; + if (x*x + y*y == z*z) { + return true;} + else { + return false;}}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}, + so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}, + so); + triples + .take(tripletCount) + .subscribe( + rxu::apply_to([&ct](int x,int y,int z){ + ++ct;}), + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return ct == tripletCount;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat serial pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; } } } diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 9c6d51d..c0a9b60 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -45,7 +45,7 @@ SCENARIO("pythagorian for loops", "[hide][for][pythagorian][perf]"){ auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "pythagorian for : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; } } @@ -90,7 +90,7 @@ SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][pe auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "merge pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "merge pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; } } @@ -108,7 +108,68 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn auto sc = rxsc::make_event_loop(); //auto sc = rxsc::make_new_thread(); - auto so = rx::identity_one_worker(sc); + auto so = rx::synchronize_in_one_worker(sc); + + int c = 0; + std::atomic ct(0); + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, so) + .flat_map( + [&c, so](int z){ + return rxs::range(1, z, 1, so) + .flat_map( + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) + .filter([&c, z, x](int y){ + ++c; + if (x*x + y*y == z*z) { + return true;} + else { + return false;}}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}, + so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}, + so); + triples + .take(tripletCount) + .subscribe( + rxu::apply_to([&ct](int x,int y,int z){ + ++ct;}), + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return ct == tripletCount;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "merge sync pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + } + } +} + +SCENARIO("serialize flat_map pythagorian ranges", "[hide][range][flat_map][serialize][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rx::serialize_one_worker(sc); int c = 0; std::atomic ct(0); @@ -152,7 +213,7 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); - std::cout << "merge sync pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << std::endl; + std::cout << "merge serial pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; } } } diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 926a347..1e96068 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -57,6 +57,48 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ } } +SCENARIO("serialize merge ranges", "[hide][range][serialize][merge][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("some ranges"){ + WHEN("generating ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto sc = rxsc::make_event_loop(); + //auto sc = rxsc::make_new_thread(); + auto so = rx::serialize_one_worker(sc); + + std::atomic c(0); + int n = 1; + auto sectionCount = onnextcalls / 3; + auto start = clock::now(); + rxs::range(0, sectionCount - 1, 1, so) + .merge( + so, + rxs::range(sectionCount, (sectionCount * 2) - 1, 1, so), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) + .subscribe( + [&c](int x){ + ++c;}, + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one(); + }); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return c == onnextcalls;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "merge serial ranges : " << n << " subscribed, " << c << " emitted, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + SCENARIO("merge completes", "[merge][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ auto sc = rxsc::make_test(); diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 18d66b5..783a774 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -52,7 +52,7 @@ SCENARIO("for loop subscribes to map", "[hide][for][just][subscribe][long][perf] } } -SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][subscribe][long][perf]"){ +SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_latest][subscribe][long][perf]"){ const int& subscriptions = static_subscriptions; GIVEN("a for loop"){ WHEN("subscribe 100K times"){ diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 652df5e..abd1c7d 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -19,11 +19,14 @@ endif() get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) -set(TEST_DIR ${RXCPP_DIR}/Rx/v2/test) -set(EXAMPLES_DIR ${RXCPP_DIR}/Rx/v2/examples) +MESSAGE( STATUS "RXCPP_DIR: " ${RXCPP_DIR} ) + include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) + +set(TEST_DIR ${RXCPP_DIR}/Rx/v2/test) + # define the sources of the self test set(TEST_SOURCES ${TEST_DIR}/test.cpp @@ -49,6 +52,8 @@ set(TEST_SOURCES add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) +set(EXAMPLES_DIR ${RXCPP_DIR}/Rx/v2/examples) + # define the sources of the pythagorian example set(PYTHAGORIAN_SOURCES ${EXAMPLES_DIR}/pythagorian/main.cpp -- GitLab From 85911e69946f653d026753690bfa623b9cad44a9 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 16 Jun 2014 09:31:47 -0700 Subject: [PATCH 339/782] add behavior and publish overload --- Rx/v2/src/rxcpp/rx-observable.hpp | 10 ++ Rx/v2/src/rxcpp/rx-subjects.hpp | 1 + Rx/v2/src/rxcpp/subjects/rx-behavior.hpp | 104 +++++++++++++++++++ Rx/v2/test/operators/publish.cpp | 126 +++++++++++++++++++++-- 4 files changed, 232 insertions(+), 9 deletions(-) create mode 100644 Rx/v2/src/rxcpp/subjects/rx-behavior.hpp diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index caeb876..266fc32 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -610,12 +610,22 @@ public: /// publish -> /// turns a cold observable hot and allows connections to the source to be independent of subscriptions + /// NOTE: multicast of a subject /// auto publish(composite_subscription cs = composite_subscription()) const -> decltype(multicast(rxsub::subject(cs))) { return multicast(rxsub::subject(cs)); } + /// publish -> + /// turns a cold observable hot, sends the most recent value to any new subscriber and allows connections to the source to be independent of subscriptions + /// NOTE: multicast of a behavior + /// + auto publish(T first, composite_subscription cs = composite_subscription()) const + -> decltype(multicast(rxsub::behavior(first, cs))) { + return multicast(rxsub::behavior(first, cs)); + } + /// scan -> /// for each item from this observable use Accumulator to combine items into a value that will be emitted from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-subjects.hpp b/Rx/v2/src/rxcpp/rx-subjects.hpp index 3c3fb32..c7ad600 100644 --- a/Rx/v2/src/rxcpp/rx-subjects.hpp +++ b/Rx/v2/src/rxcpp/rx-subjects.hpp @@ -17,6 +17,7 @@ namespace rxsub=subjects; } #include "subjects/rx-subject.hpp" +#include "subjects/rx-behavior.hpp" #include "subjects/rx-synchronize.hpp" #endif diff --git a/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp b/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp new file mode 100644 index 0000000..539f8d6 --- /dev/null +++ b/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp @@ -0,0 +1,104 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_BEHAVIOR_HPP) +#define RXCPP_RX_BEHAVIOR_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace subjects { + +namespace detail { + +template +class behavior_observer : public detail::multicast_observer +{ + typedef behavior_observer this_type; + typedef detail::multicast_observer base_type; + + class behavior_observer_state : public std::enable_shared_from_this + { + mutable std::mutex lock; + mutable T value; + + public: + behavior_observer_state(T first) + : value(first) + { + } + + void reset(T v) const { + std::unique_lock guard(lock); + value = std::move(v); + } + T get() const { + std::unique_lock guard(lock); + return value; + } + }; + + std::shared_ptr state; + +public: + behavior_observer(T f, composite_subscription l) + : base_type(l) + , state(std::make_shared(std::move(f))) + { + } + + T get_value() const { + return state->get(); + } + + template + void on_next(V v) const { + state->reset(v); + base_type::on_next(std::move(v)); + } +}; + +} + +template +class behavior +{ + composite_subscription lifetime; + detail::behavior_observer s; + +public: + explicit behavior(T f, composite_subscription cs = composite_subscription()) + : lifetime(std::move(cs)) + , s(std::move(f), lifetime) + { + } + + bool has_observers() const { + return s.has_observers(); + } + + T get_value() const { + return s.get_value(); + } + + subscriber get_subscriber() const { + return make_subscriber(lifetime, make_observer_dynamic(observer>(s))); + } + + observable get_observable() const { + return make_observable_dynamic([this](subscriber o){ + if (lifetime.is_subscribed()) { + o.on_next(get_value()); + } + this->s.add(std::move(o)); + }); + } +}; + +} + +} + +#endif diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 464f7d2..7c6fd5f 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -13,7 +13,7 @@ namespace rxt=rxcpp::test; #include "catch.hpp" -SCENARIO("publish range", "[hide][range][subject][publish][operators]"){ +SCENARIO("publish range", "[hide][range][subject][publish][subject][operators]"){ GIVEN("a range"){ WHEN("published"){ auto published = rxs::range(0, 10).publish(); @@ -47,7 +47,7 @@ SCENARIO("publish range", "[hide][range][subject][publish][operators]"){ } } -SCENARIO("publish basic", "[publish][multicast][operators]"){ +SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ GIVEN("a test hot observable of longs"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -58,8 +58,6 @@ SCENARIO("publish basic", "[publish][multicast][operators]"){ auto on_completed = m::on_completed; auto subscribe = m::subscribe; - long invoked = 0; - record messages[] = { on_next(110, 7), on_next(220, 3), @@ -85,7 +83,7 @@ SCENARIO("publish basic", "[publish][multicast][operators]"){ WHEN("subscribed and then connected"){ w.schedule_absolute(rxsc::test::created_time, - [&invoked, &ys, &xs](const rxsc::schedulable& scbl){ + [&ys, &xs](const rxsc::schedulable& scbl){ ys = xs.publish().as_dynamic(); //ys = xs.publish_last().as_dynamic(); }); @@ -170,7 +168,7 @@ SCENARIO("publish basic", "[publish][multicast][operators]"){ } -SCENARIO("publish error", "[publish][error][multicast][operators]"){ +SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ GIVEN("a test hot observable of longs"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -182,8 +180,6 @@ SCENARIO("publish error", "[publish][error][multicast][operators]"){ auto on_completed = m::on_completed; auto subscribe = m::subscribe; - long invoked = 0; - std::runtime_error ex("publish on_error"); record messages[] = { @@ -211,7 +207,7 @@ SCENARIO("publish error", "[publish][error][multicast][operators]"){ WHEN("subscribed and then connected"){ w.schedule_absolute(rxsc::test::created_time, - [&invoked, &ys, &xs](const rxsc::schedulable& scbl){ + [&ys, &xs](const rxsc::schedulable& scbl){ ys = xs.publish().as_dynamic(); }); @@ -281,3 +277,115 @@ SCENARIO("publish error", "[publish][error][multicast][operators]"){ } } } + +SCENARIO("publish basic with initial value", "[publish][multicast][behavior][operators]"){ + GIVEN("a test hot observable of longs"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(110, 7), + on.on_next(220, 3), + on.on_next(280, 4), + on.on_next(290, 1), + on.on_next(340, 8), + on.on_next(360, 5), + on.on_next(370, 6), + on.on_next(390, 7), + on.on_next(410, 13), + on.on_next(430, 2), + on.on_next(450, 9), + on.on_next(520, 11), + on.on_next(560, 20), + on.on_completed(600) + }); + + auto res = w.make_subscriber(); + + rx::connectable_observable ys; + + WHEN("subscribed and then connected"){ + + w.schedule_absolute(rxsc::test::created_time, + [&ys, &xs](const rxsc::schedulable& scbl){ + ys = xs.publish(1979).as_dynamic(); + }); + + w.schedule_absolute(rxsc::test::subscribed_time, + [&ys, &res](const rxsc::schedulable& scbl){ + ys.subscribe(res); + }); + + w.schedule_absolute(rxsc::test::unsubscribed_time, + [&res](const rxsc::schedulable& scbl){ + res.unsubscribe(); + }); + + { + rx::composite_subscription connection; + + w.schedule_absolute(300, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + w.schedule_absolute(400, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + { + rx::composite_subscription connection; + + w.schedule_absolute(500, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + w.schedule_absolute(550, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + { + rx::composite_subscription connection; + + w.schedule_absolute(650, + [connection, &ys](const rxsc::schedulable& scbl){ + ys.connect(connection); + }); + w.schedule_absolute(800, + [connection](const rxsc::schedulable& scbl){ + connection.unsubscribe(); + }); + } + + w.start(); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(200, 1979), + on.on_next(340, 8), + on.on_next(360, 5), + on.on_next(370, 6), + on.on_next(390, 7), + on.on_next(520, 11) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there were 3 subscription/unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(300, 400), + on.subscribe(500, 550), + on.subscribe(650, 800) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} -- GitLab From 9215a5b4d9cce3dba031d5932d63fb8cadda3d2a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 16 Jun 2014 23:09:58 -0700 Subject: [PATCH 340/782] add reduce, sum and average because sum and average fail to compile, due to observable being a partial class at that point, a hack was added for sum and average. They are spelled: o.reduce_to(rxo::sum) o.reduce_to(rxo::average) --- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 244 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 36 +-- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/src/rxcpp/rx-predef.hpp | 22 ++ Rx/v2/src/rxcpp/rx-util.hpp | 4 +- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 2 +- Rx/v2/test/operators/reduce.cpp | 113 +++++++++ projects/CMake/CMakeLists.txt | 1 + 8 files changed, 406 insertions(+), 17 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-reduce.hpp create mode 100644 Rx/v2/test/operators/reduce.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp new file mode 100644 index 0000000..e12d820 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -0,0 +1,244 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_REDUCE_HPP) +#define RXCPP_OPERATORS_RX_REDUCE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct reduce_traits +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type accumulator_type; + typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type seed_type; + + typedef T source_value_type; + + struct tag_not_valid {}; + + template + static auto accumulate_check(int) -> decltype((*(CRS*)nullptr)(*(CS*)nullptr, *(CV*)nullptr)); + template + static tag_not_valid accumulate_check(...); + + static_assert(std::is_same(0)), seed_type>::value, "reduce Accumulator must be a function with the signature Seed(Seed, reduce::source_value_type)"); + + template + static auto result_check(int) -> decltype((*(CRS*)nullptr)(*(CS*)nullptr)); + template + static tag_not_valid result_check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "reduce ResultSelector must be a function with the signature reduce::value_type(Seed)"); + + typedef decltype(result_check(0)) value_type; +}; + +template +struct reduce : public operator_base::value_type> +{ + typedef reduce this_type; + typedef reduce_traits traits; + + typedef typename traits::source_type source_type; + typedef typename traits::accumulator_type accumulator_type; + typedef typename traits::result_selector_type result_selector_type; + typedef typename traits::seed_type seed_type; + + typedef typename traits::source_value_type source_value_type; + typedef typename traits::value_type value_type; + + struct reduce_initial_type + { + reduce_initial_type(source_type o, accumulator_type a, result_selector_type rs, seed_type s) + : source(std::move(o)) + , accumulator(std::move(a)) + , result_selector(std::move(rs)) + , seed(std::move(s)) + { + } + source_type source; + accumulator_type accumulator; + result_selector_type result_selector; + seed_type seed; + }; + reduce_initial_type initial; + + reduce(source_type o, accumulator_type a, result_selector_type rs, seed_type s) + : initial(std::move(o), std::move(a), std::move(rs), std::move(s)) + { + } + template + void on_subscribe(Subscriber o) { + struct reduce_state_type + : public reduce_initial_type + , public std::enable_shared_from_this + { + reduce_state_type(reduce_initial_type i, Subscriber scrbr) + : reduce_initial_type(i) + , current(reduce_initial_type::seed) + , out(std::move(scrbr)) + { + } + seed_type current; + Subscriber out; + }; + auto state = std::make_shared(initial, std::move(o)); + state->source.subscribe( + state->out, + // on_next + [state](T t) { + auto next = on_exception( + [&](){return state->accumulator(state->current, t);}, + state->out); + if (next.empty()) { + return; + } + state->current = next.get(); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + auto result = on_exception( + [&](){return state->result_selector(state->current);}, + state->out); + if (result.empty()) { + return; + } + state->out.on_next(result.get()); + state->out.on_completed(); + } + ); + } +}; + +template +class reduce_factory +{ + typedef typename std::decay::type accumulator_type; + typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type seed_type; + + accumulator_type accumulator; + result_selector_type result_selector; + seed_type seed; +public: + reduce_factory(accumulator_type a, result_selector_type rs, Seed s) + : accumulator(std::move(a)) + , result_selector(std::move(rs)) + , seed(std::move(s)) + { + } + template + auto operator()(Observable&& source) + -> observable::type::value_type, Observable, Accumulator, ResultSelector, Seed>> { + return observable::type::value_type, Observable, Accumulator, ResultSelector, Seed>>( + reduce::type::value_type, Observable, Accumulator, ResultSelector, Seed>(std::forward(source), accumulator, result_selector, seed)); + } +}; + +template +struct initialize_seeder { + typedef T seed_type; + seed_type seed() { + return seed_type{}; + } +}; + +template +struct average { + struct seed_type + { + seed_type() + : value() + , count(0) + { + } + T value; + int count; + rxu::detail::maybe stage; + }; + seed_type seed() { + return seed_type{}; + } + seed_type operator()(seed_type a, T v) { + if (a.count != 0 && + (a.count == std::numeric_limits::max() || + ((v > 0) && (a.value > (std::numeric_limits::max() - v))) || + ((v < 0) && (a.value < (std::numeric_limits::min() - v))))) { + // would overflow, calc existing and reset for next batch + // this will add error to the final result, but the alternative + // is to fail on overflow + double avg = a.value / a.count; + a.value = v; + a.count = 1; + if (!a.stage.empty()) { + a.stage.reset((*a.stage + avg) / 2); + } else { + a.stage.reset(avg); + } + } else { + a.value += v; + ++a.count; + } + return a; + } + double operator()(seed_type a) { + if (a.count > 0) { + double avg = a.value / a.count; + if (!a.stage.empty()) { + avg = (*a.stage + avg) / 2; + } + return avg; + } + return a.value; + } +}; + +} + +template +auto reduce(Seed s, Accumulator a, ResultSelector rs) + -> detail::reduce_factory { + return detail::reduce_factory(std::move(a), std::move(rs), std::move(s)); +} + +template class Seeder, template class Accumulator, template class ResultSelector> +struct specific_reduce +{ + template + Accumulator accumulator() const { + return Accumulator{}; + } + template + ResultSelector result_selector() const { + return ResultSelector{}; + } + template + auto seed() const + -> typename Seeder::seed_type { + return Seeder().seed(); + } +}; + +static const specific_reduce sum{}; + +static const specific_reduce average{}; + + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 266fc32..d4e0ca6 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -74,20 +74,6 @@ struct select_chain } -// -// this type is the default used by operators that subscribe to -// multiple sources. It assumes that the sources are already synchronized -// -struct identity_observable -{ - template - auto operator()(Observable o) - -> Observable { - return std::move(o); - static_assert(is_observable::value, "only support observables"); - } -}; - template class dynamic_observable : public rxs::source_base @@ -626,6 +612,28 @@ public: return multicast(rxsub::behavior(first, cs)); } + /// reduce -> + /// for each item from this observable use Accumulator to combine items, when completed use ResultSelector to produce a value that will be emitted from the new observable that is returned. + /// + template + auto reduce(Seed seed, Accumulator&& a, ResultSelector&& rs) const + -> observable::value_type, rxo::detail::reduce> { + return observable::value_type, rxo::detail::reduce>( + rxo::detail::reduce(*this, std::forward(a), std::forward(rs), seed)); + } + + /// reduce_to -> + /// for each item from this observable reduce it using the Accumulator and ResultSelector and Seed. + /// NOTE: this overload allows constants like rxo::sum and rxo::average to be passed in. Adding a + /// sum or average method here causes compile errors because they are not templated and this type + /// is a partial type at this point. + /// + template class Seeder, template class Accumulator, template class ResultSelector> + auto reduce_to(rxo::specific_reduce sr) const + -> decltype(reduce(sr.template seed(), sr.template accumulator(), sr.template result_selector())) { + return reduce(sr.template seed(), sr.template accumulator(), sr.template result_selector()); + } + /// scan -> /// for each item from this observable use Accumulator to combine items into a value that will be emitted from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index b535e17..9c75547 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -49,6 +49,7 @@ namespace rxo=operators; #include "operators/rx-publish.hpp" #include "operators/rx-ref_count.hpp" #include "operators/rx-connect_forever.hpp" +#include "operators/rx-reduce.hpp" #include "operators/rx-scan.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 688c8ea..482b89e 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -182,6 +182,28 @@ public: static const bool value = std::is_convertible::type>(0)), tag_connectable_observable>::value; }; +// +// this type is the default used by operators that subscribe to +// multiple sources. It assumes that the sources are already synchronized +// +struct identity_observable +{ + template + auto operator()(Observable o) + -> Observable { + return std::move(o); + static_assert(is_observable::value, "only support observables"); + } +}; + +template +struct identity_for +{ + T operator()(T t) { + return std::move(t); + } +}; + } #endif diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index dd307b2..e30ff7f 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -278,8 +278,8 @@ public: return *this; } maybe& operator=(const maybe& other) { - if (const T* pother = other.get()) { - reset(*pother); + if (!other.empty()) { + reset(other.get()); } else { reset(); } diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index fce04ac..46408f8 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -86,8 +86,8 @@ class synchronize_observer : public detail::multicast_observer synchronize_observer_state(coordinator_type coor, composite_subscription cs, output_type scbr) : lifetime(std::move(cs)) - , coordinator(std::move(coor)) , current(mode::Empty) + , coordinator(std::move(coor)) , destination(std::move(scbr)) { } diff --git a/Rx/v2/test/operators/reduce.cpp b/Rx/v2/test/operators/reduce.cpp new file mode 100644 index 0000000..45aba91 --- /dev/null +++ b/Rx/v2/test/operators/reduce.cpp @@ -0,0 +1,113 @@ + +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("reduce some data with seed", "[reduce][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int seed = 42; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 0), + on.on_next(220, 1), + on.on_next(230, 2), + on.on_next(240, 3), + on.on_next(250, 4), + on.on_completed(260) + }); + + auto sum = xs.reduce_to(rxo::sum); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .reduce(seed, + [](int sum, int x) { + return sum + x; + }, + [](int sum) { + return sum * 5; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_next(260, (seed + 0 + 1 + 2 + 3 + 4) * 5), + on.on_completed(260) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 260) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("average some data", "[reduce][average][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 3), + on.on_next(220, 4), + on.on_next(230, 2), + on.on_completed(250) + }); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs.reduce_to(rxo::average); + } + ); + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_next(250, 3.0), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index abd1c7d..b9e6df6 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -43,6 +43,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/filter.cpp ${TEST_DIR}/operators/distinct_until_changed.cpp ${TEST_DIR}/operators/scan.cpp + ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/flat_map.cpp -- GitLab From c96e2a497e3876287e3ef5824f8d8164cb3ebf3a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 19 Jun 2014 08:24:37 -0700 Subject: [PATCH 341/782] added switch_on_next and replaced reduce_to observable now has sum() and average() --- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 72 +++--- .../src/rxcpp/operators/rx-switch_on_next.hpp | 210 ++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 92 +++++++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/reduce.cpp | 13 +- Rx/v2/test/operators/switch_on_next.cpp | 114 ++++++++++ projects/CMake/CMakeLists.txt | 1 + 8 files changed, 459 insertions(+), 52 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp create mode 100644 Rx/v2/test/operators/switch_on_next.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 5eddc15..684a13c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -14,13 +14,19 @@ namespace operators { namespace detail { template -struct merge : public operator_base::type::value_type::value_type> +struct merge + : public operator_base::type::value_type::value_type> { + static_assert(is_observable::value, "merge requires an observable"); + static_assert(is_observable::value, "merge an observable that contains observables"); + typedef merge this_type; typedef typename std::decay::type source_type; + typedef typename source_type::value_type source_value_type; typedef typename source_value_type::value_type value_type; + typedef typename std::decay::type coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index e12d820..7ba7015 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -13,33 +13,55 @@ namespace operators { namespace detail { -template -struct reduce_traits -{ - typedef typename std::decay::type source_type; +template +struct is_accumulate_function_for { + typedef typename std::decay::type accumulator_type; - typedef typename std::decay::type result_selector_type; typedef typename std::decay::type seed_type; - typedef T source_value_type; struct tag_not_valid {}; - template - static auto accumulate_check(int) -> decltype((*(CRS*)nullptr)(*(CS*)nullptr, *(CV*)nullptr)); + static auto check(int) -> decltype((*(CRS*)nullptr)(*(CS*)nullptr, *(CV*)nullptr)); template - static tag_not_valid accumulate_check(...); + static tag_not_valid check(...); + + typedef decltype(check(0)) type; + static const bool value = std::is_same::value; +}; - static_assert(std::is_same(0)), seed_type>::value, "reduce Accumulator must be a function with the signature Seed(Seed, reduce::source_value_type)"); +template +struct is_result_function_for { + + typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type seed_type; + + struct tag_not_valid {}; template - static auto result_check(int) -> decltype((*(CRS*)nullptr)(*(CS*)nullptr)); + static auto check(int) -> decltype((*(CRS*)nullptr)(*(CS*)nullptr)); template - static tag_not_valid result_check(...); + static tag_not_valid check(...); + + typedef decltype(check(0)) type; + static const bool value = !std::is_same::value; +}; + +template +struct reduce_traits +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type accumulator_type; + typedef typename std::decay::type result_selector_type; + typedef typename std::decay::type seed_type; + + typedef T source_value_type; - static_assert(!std::is_same(0)), tag_not_valid>::value, "reduce ResultSelector must be a function with the signature reduce::value_type(Seed)"); + static_assert(is_accumulate_function_for::value, "reduce Accumulator must be a function with the signature Seed(Seed, reduce::source_value_type)"); - typedef decltype(result_check(0)) value_type; + static_assert(is_result_function_for::value, "reduce ResultSelector must be a function with the signature reduce::value_type(Seed)"); + + typedef typename is_result_function_for::type value_type; }; template @@ -214,28 +236,6 @@ auto reduce(Seed s, Accumulator a, ResultSelector rs) return detail::reduce_factory(std::move(a), std::move(rs), std::move(s)); } -template class Seeder, template class Accumulator, template class ResultSelector> -struct specific_reduce -{ - template - Accumulator accumulator() const { - return Accumulator{}; - } - template - ResultSelector result_selector() const { - return ResultSelector{}; - } - template - auto seed() const - -> typename Seeder::seed_type { - return Seeder().seed(); - } -}; - -static const specific_reduce sum{}; - -static const specific_reduce average{}; - } diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp new file mode 100644 index 0000000..b47fd12 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -0,0 +1,210 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_SWITCH_ON_NEXT_HPP) +#define RXCPP_OPERATORS_RX_SWITCH_ON_NEXT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct switch_on_next + : public operator_base::type::value_type::value_type> +{ + static_assert(is_observable::value, "switch_on_next requires an observable"); + static_assert(is_observable::value, "switch_on_next an observable that contains observables"); + + typedef switch_on_next this_type; + + typedef typename std::decay::type source_type; + + typedef typename source_type::value_type collection_type; + typedef typename collection_type::value_type collection_value_type; + + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + + struct values + { + values(source_type o, coordination_type sf) + : source(std::move(o)) + , coordination(std::move(sf)) + { + } + source_type source; + coordination_type coordination; + }; + values initial; + + switch_on_next(source_type o, coordination_type sf) + : initial(std::move(o), std::move(sf)) + { + } + + template + void on_subscribe(Subscriber scbr) const { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef Subscriber output_type; + + struct switch_state_type + : public std::enable_shared_from_this + , public values + { + switch_state_type(values i, coordinator_type coor, output_type oarg) + : values(std::move(i)) + , pendingCompletions(0) + , coordinator(std::move(coor)) + , out(std::move(oarg)) + { + } + // on_completed on the output must wait until all the + // subscriptions have received on_completed + int pendingCompletions; + coordinator_type coordinator; + composite_subscription inner_lifetime; + output_type out; + }; + + auto coordinator = initial.coordination.create_coordinator(); + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new switch_state_type(initial, std::move(coordinator), std::move(scbr))); + + composite_subscription outercs; + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.add(outercs); + + auto source = on_exception( + [&](){return state->coordinator.in(state->source);}, + state->out); + if (source.empty()) { + return; + } + + ++state->pendingCompletions; + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + auto sink = make_subscriber( + state->out, + outercs, + // on_next + [state](collection_type st) { + + state->inner_lifetime.unsubscribe(); + + state->inner_lifetime = composite_subscription(); + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + auto innerlifetimetoken = state->out.add(state->inner_lifetime); + + state->inner_lifetime.add(make_subscription([state, innerlifetimetoken](){ + state->out.remove(innerlifetimetoken); + --state->pendingCompletions; + })); + + auto selectedSource = on_exception( + [&](){return state->coordinator.in(st);}, + state->out); + if (selectedSource.empty()) { + return; + } + + // this subscribe does not share the source subscription + // so that when it is unsubscribed the source will continue + auto sinkInner = make_subscriber( + state->out, + state->inner_lifetime, + // on_next + [state, st](collection_value_type ct) { + state->out.on_next(std::move(ct)); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + //on_completed + [state](){ + if (state->pendingCompletions == 1) { + state->out.on_completed(); + } + } + ); + + auto selectedSinkInner = on_exception( + [&](){return state->coordinator.out(sinkInner);}, + state->out); + if (selectedSinkInner.empty()) { + return; + } + + ++state->pendingCompletions; + selectedSource->subscribe(std::move(selectedSinkInner.get())); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (--state->pendingCompletions == 0) { + state->out.on_completed(); + } + } + ); + + auto selectedSink = on_exception( + [&](){return state->coordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + + source->subscribe(std::move(selectedSink.get())); + + } +}; + +template +class switch_on_next_factory +{ + typedef typename std::decay::type coordination_type; + + coordination_type coordination; +public: + switch_on_next_factory(coordination_type sf) + : coordination(std::move(sf)) + { + } + + template + auto operator()(Observable&& source) + -> observable::value_type, switch_on_next> { + return observable::value_type, switch_on_next>( + switch_on_next(std::forward(source), coordination)); + } +}; + +} + +template +auto switch_on_next(Coordination&& sf) + -> detail::switch_on_next_factory { + return detail::switch_on_next_factory(std::forward(sf)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index d4e0ca6..6679213 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -335,6 +335,51 @@ public: return lift(rxo::detail::buffer_count(count, skip)); } + template::value> + struct switch_on_next_result; + + template + struct switch_on_next_result + { + typedef + observable< + typename this_type::value_type::value_type, + rxo::detail::switch_on_next> + type; + static type make(const this_type* that, Coordination sf) { + return type(rxo::detail::switch_on_next(*that, std::move(sf))); + } + }; + template + struct switch_on_next_result + { + typedef this_type type; + static type make(const this_type* that, Coordination) { + return *that; + } + }; + + /// switch_on_next (AKA Switch) -> + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// for each item from this observable subscribe to that observable after unsubscribing from any previous subscription. + /// + auto switch_on_next() const + -> typename switch_on_next_result::type { + return switch_on_next_result::make(this, identity_one_worker(rxsc::make_current_thread())); + } + + /// switch_on_next (AKA Switch) -> + /// The coodination is used to synchronize sources from different contexts. + /// for each item from this observable subscribe to that observable after unsubscribing from any previous subscription. + /// + template + auto switch_on_next(Coordination&& sf) const + -> typename std::enable_if::value, + observable::value_type, rxo::detail::switch_on_next>>::type { + return observable::value_type, rxo::detail::switch_on_next>( + rxo::detail::switch_on_next(*this, std::forward(sf))); + } + template::value> struct merge_result; @@ -622,16 +667,45 @@ public: rxo::detail::reduce(*this, std::forward(a), std::forward(rs), seed)); } - /// reduce_to -> - /// for each item from this observable reduce it using the Accumulator and ResultSelector and Seed. - /// NOTE: this overload allows constants like rxo::sum and rxo::average to be passed in. Adding a - /// sum or average method here causes compile errors because they are not templated and this type - /// is a partial type at this point. + template::value && + rxo::detail::is_result_function_for::value> + struct specific_reduce_result; + + template + struct specific_reduce_result + { + typedef + observable< + typename rxo::detail::is_result_function_for::type, + rxo::detail::reduce> + type; + static type make(const this_type* that, Seed seed, Accumulator a, ResultSelector rs) { + return type(rxo::detail::reduce(*that, std::move(a), std::move(rs), std::move(seed))); + } + }; + template + struct specific_reduce_result + { + typedef void type; + static void make(const this_type* that, Seed, Accumulator, ResultSelector) { + } + }; + + /// sum -> + /// for each item from this observable reduce it by adding to the previous values. + /// + auto sum() const + -> typename specific_reduce_result::seed_type, std::plus, identity_for>::type { + return specific_reduce_result::seed_type, std::plus, identity_for>::make(this, rxo::detail::initialize_seeder().seed(), std::plus(), identity_for()); + } + + /// average -> + /// for each item from this observable reduce it by adding to the previous values and then dividing by the number of items at the end. /// - template class Seeder, template class Accumulator, template class ResultSelector> - auto reduce_to(rxo::specific_reduce sr) const - -> decltype(reduce(sr.template seed(), sr.template accumulator(), sr.template result_selector())) { - return reduce(sr.template seed(), sr.template accumulator(), sr.template result_selector()); + auto average() const + -> typename specific_reduce_result::seed_type, rxo::detail::average, rxo::detail::average>::type { + return specific_reduce_result::seed_type, rxo::detail::average, rxo::detail::average>::make(this, rxo::detail::average().seed(), rxo::detail::average(), rxo::detail::average()); } /// scan -> diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 9c75547..fbc2c01 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -51,6 +51,7 @@ namespace rxo=operators; #include "operators/rx-connect_forever.hpp" #include "operators/rx-reduce.hpp" #include "operators/rx-scan.hpp" +#include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" diff --git a/Rx/v2/test/operators/reduce.cpp b/Rx/v2/test/operators/reduce.cpp index 45aba91..a45354b 100644 --- a/Rx/v2/test/operators/reduce.cpp +++ b/Rx/v2/test/operators/reduce.cpp @@ -31,11 +31,11 @@ SCENARIO("reduce some data with seed", "[reduce][operators]"){ on.on_completed(260) }); - auto sum = xs.reduce_to(rxo::sum); + auto sum = xs.sum(); WHEN("mapped to ints that are one larger"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .reduce(seed, @@ -75,6 +75,7 @@ SCENARIO("average some data", "[reduce][average][operators]"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); const rxsc::test::messages on; + const rxsc::test::messages d_on; auto xs = sc.make_hot_observable({ on.on_next(150, 1), @@ -86,16 +87,16 @@ SCENARIO("average some data", "[reduce][average][operators]"){ WHEN("mapped to ints that are one larger"){ - auto res = w.start( + auto res = w.start( [&]() { - return xs.reduce_to(rxo::average); + return xs.average(); } ); THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(250, 3.0), - on.on_completed(250) + d_on.on_next(250, 3.0), + d_on.on_completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/switch_on_next.cpp b/Rx/v2/test/operators/switch_on_next.cpp new file mode 100644 index 0000000..f6f70b0 --- /dev/null +++ b/Rx/v2/test/operators/switch_on_next.cpp @@ -0,0 +1,114 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxo=rxcpp::operators; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; +namespace rxn=rxcpp::notifications; + +#include "rxcpp/rx-test.hpp" +namespace rxt=rxcpp::test; + +#include "catch.hpp" + +SCENARIO("switch_on_next - some changes", "[switch_on_next][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto ys2 = sc.make_cold_observable({ + on.on_next(10, 201), + on.on_next(20, 202), + on.on_next(30, 203), + on.on_next(40, 204), + on.on_completed(50) + }); + + auto ys3 = sc.make_cold_observable({ + on.on_next(10, 301), + on.on_next(20, 302), + on.on_next(30, 303), + on.on_next(40, 304), + on.on_completed(150) + }); + + auto xs = sc.make_hot_observable({ + o_on.on_next(300, ys1), + o_on.on_next(400, ys2), + o_on.on_next(500, ys3), + o_on.on_completed(600) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.switch_on_next(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 201), + on.on_next(420, 202), + on.on_next(430, 203), + on.on_next(440, 204), + on.on_next(510, 301), + on.on_next(520, 302), + on.on_next(530, 303), + on.on_next(540, 304), + on.on_completed(650) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys1"){ + auto required = rxu::to_vector({ + on.subscribe(300, 400) + }); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys2"){ + auto required = rxu::to_vector({ + on.subscribe(400, 450) + }); + auto actual = ys2.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys3"){ + auto required = rxu::to_vector({ + on.subscribe(500, 650) + }); + auto actual = ys3.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b9e6df6..8778802 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -43,6 +43,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/filter.cpp ${TEST_DIR}/operators/distinct_until_changed.cpp ${TEST_DIR}/operators/scan.cpp + ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/publish.cpp -- GitLab From 83f6fdf29056f6a18e2825ef2f4c4b61dad62c30 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 19 Jun 2014 08:25:10 -0700 Subject: [PATCH 342/782] remove RelWithDebInfo --- .travis.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 51435aa..d777288 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,7 +9,6 @@ compiler: - clang env: - - BUILD_TYPE=RelWithDebInfo - BUILD_TYPE=Release before_install: @@ -25,7 +24,7 @@ install: script: - cd projects/build - ctest -V - - cd .. + - cd ../.. branches: only: @@ -35,5 +34,5 @@ notifications: recipients: - kirk.shoop@microsoft.com email: - on_success: change + on_success: always on_failure: always -- GitLab From 76bfc895a34d07c3ccb03361699df1a187025b2d Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 24 Jun 2014 19:48:06 +0400 Subject: [PATCH 343/782] GCC forbids "__thread" before "static". --- Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 7578272..3c7bb90 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -32,7 +32,7 @@ public: private: static current_thread_queue_type*& current_thread_queue() { - RXCPP_THREAD_LOCAL static current_thread_queue_type* queue; + static RXCPP_THREAD_LOCAL current_thread_queue_type* queue; return queue; } -- GitLab From 7eb61bd4dd9d82968561c9335e9379c02a34bf2d Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 24 Jun 2014 19:49:22 +0400 Subject: [PATCH 344/782] GCC requires explicit using of "this". Visual C++ does not support this feature, so we need a macro depending on compiler. --- Rx/v2/src/rxcpp/rx-observable.hpp | 34 ++++++++++++++++++------------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 6679213..0ec1123 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -7,6 +7,12 @@ #include "rx-includes.hpp" +#ifdef __GNUG__ +#define EXPLICIT_THIS this-> +#else +#define EXPLICIT_THIS +#endif + namespace rxcpp { namespace detail { @@ -298,8 +304,8 @@ public: /// template auto filter(Predicate p) const - -> decltype(lift(rxo::detail::filter(std::move(p)))) { - return lift(rxo::detail::filter(std::move(p))); + -> decltype(EXPLICIT_THIS lift(rxo::detail::filter(std::move(p)))) { + return lift(rxo::detail::filter(std::move(p))); } /// map (AKA Select) -> @@ -307,32 +313,32 @@ public: /// template auto map(Selector&& s) const - -> decltype(lift(rxo::detail::map(std::move(s)))) { - return lift(rxo::detail::map(std::move(s))); + -> decltype(EXPLICIT_THIS lift(rxo::detail::map(std::move(s)))) { + return lift(rxo::detail::map(std::move(s))); } /// distinct_until_changed -> /// for each item from this observable, filter out repeated values and emit only changes from the new observable that is returned. /// auto distinct_until_changed() const - -> decltype(lift(rxo::detail::distinct_until_changed())) { - return lift(rxo::detail::distinct_until_changed()); + -> decltype(EXPLICIT_THIS lift(rxo::detail::distinct_until_changed())) { + return lift(rxo::detail::distinct_until_changed()); } /// buffer -> /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// auto buffer(int count) const - -> decltype(lift(rxo::detail::buffer_count(count, count))) { - return lift(rxo::detail::buffer_count(count, count)); + -> decltype(EXPLICIT_THIS lift(rxo::detail::buffer_count(count, count))) { + return lift(rxo::detail::buffer_count(count, count)); } /// buffer -> /// start a new vector every skip items and collect count items from this observable into each vector to emit from the new observable that is returned. /// auto buffer(int count, int skip) const - -> decltype(lift(rxo::detail::buffer_count(count, skip))) { - return lift(rxo::detail::buffer_count(count, skip)); + -> decltype(EXPLICIT_THIS lift(rxo::detail::buffer_count(count, skip))) { + return lift(rxo::detail::buffer_count(count, skip)); } template::value> @@ -635,8 +641,8 @@ public: /// template auto synchronize(Coordination cn, composite_subscription cs = composite_subscription()) const - -> decltype(multicast(rxsub::synchronize(std::move(cn), cs))) { - return multicast(rxsub::synchronize(std::move(cn), cs)); + -> decltype(EXPLICIT_THIS multicast(rxsub::synchronize(std::move(cn), cs))) { + return multicast(rxsub::synchronize(std::move(cn), cs)); } /// publish -> @@ -644,8 +650,8 @@ public: /// NOTE: multicast of a subject /// auto publish(composite_subscription cs = composite_subscription()) const - -> decltype(multicast(rxsub::subject(cs))) { - return multicast(rxsub::subject(cs)); + -> decltype(EXPLICIT_THIS multicast(rxsub::subject(cs))) { + return multicast(rxsub::subject(cs)); } /// publish -> -- GitLab From 62ba9bfecbf63d60894d9c4eda20bcaec2698998 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 24 Jun 2014 19:50:13 +0400 Subject: [PATCH 345/782] Add features support detection for GCC. --- Rx/v2/src/rxcpp/rx-includes.hpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 28ed62c..2568d9d 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -33,6 +33,24 @@ #define RXCPP_USE_VARIADIC_TEMPLATES 1 #endif +#elif defined(__GNUG__) + +#define GCC_VERSION (__GNUC__ * 10000 + \ + __GNUC_MINOR__ * 100 + \ + __GNUC_PATCHLEVEL__) + +#if GCC_VERSION >= 40801 +#define RXCPP_USE_RVALUEREF 1 +#endif + +#if GCC_VERSION >= 40400 +#define RXCPP_USE_VARIADIC_TEMPLATES 1 +#endif + +#if defined(__GXX_RTTI) +#define RXCPP_USE_RTTI 1 +#endif + #endif #if !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) -- GitLab From 08bb829c142c261c92c94259d81f64d479458ae4 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 24 Jun 2014 19:51:33 +0400 Subject: [PATCH 346/782] Use preprocessor control of using RTTI. GCC does not support string literals in function template signature and "typeid" into "decltype". --- Rx/v2/src/rxcpp/rx-notification.hpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index cc4c721..b572c27 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -65,16 +65,16 @@ auto to_stream(std::ostream& os, const T& t, int, int) return os << t; } +#if RXCPP_USE_RTTI template -auto to_stream(std::ostream& os, const T&, int, ...) - -> decltype(os << typeid(T).name() << "") { - return os << "< " << typeid(T).name() << " does not support ostream>"; +std::ostream& to_stream(std::ostream& os, const T&, int, ...) { + return os << "< " << typeid(T).name() << " does not support ostream>"; } +#endif template -auto to_stream(std::ostream& os, const T&, ...) - -> decltype(os << "") { - return os << ""; +std::ostream& to_stream(std::ostream& os, const T&, ...) { + return os << ""; } template -- GitLab From e19b1f583b440bec7f1692b181ace83ba18e374e Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 24 Jun 2014 19:51:59 +0400 Subject: [PATCH 347/782] Add build instructions for GCC. --- README.md | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 9ab9eb2..ffa1b1e 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ * RxCpp is regularly tested on OSX and Windows. * RxCpp is regularly built with Clang and VC * RxCpp depends on the latest compiler releases. -* RxCpp does not compile with gcc at this time. Contributions are welcome. +* RxCpp has an experimental build with gcc. RxCpp uses CMake to create build files for several platforms and IDE's @@ -50,6 +50,22 @@ cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake make ``` +####Linux --- Clang +``` +mkdir projects/build +cd projects/build +cmake -G"Unix Makefiles" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake +make +``` + +####Linux --- GCC +``` +mkdir projects/build +cd projects/build +cmake -G"Unix Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake +make +``` + ####Windows ``` mkdir projects\build -- GitLab From f36a3927cae94fb1d51b472534cee66c86a48102 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 24 Jun 2014 19:53:22 +0400 Subject: [PATCH 348/782] Configure Travis for GCC --- .travis.yml | 8 +++++++- projects/scripts/travis-install.sh | 14 ++++++++++++-- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index d777288..9fda0a0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,16 +7,22 @@ os: compiler: - clang + - gcc env: - BUILD_TYPE=Release + +matrix: + exclude: + - compiler: gcc + os: osx before_install: - sh projects/scripts/travis-install.sh install: - cd projects - - cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE + - cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX - cd build - make -j4 - cd ../.. diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index cb84aa4..8fb05f2 100644 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -10,8 +10,18 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang-3.5 sudo apt-get clean sudo apt-get update - sudo apt-get install -q --fix-missing clang-3.5 cmake libssl-dev -#libstdc++6 + + sudo apt-get install -q --fix-missing cmake libssl-dev + + if [ "$CC" = clang ]; then + sudo apt-get install -q --fix-missing clang-3.5 + fi + + if [ "$CC" = gcc ]; then + sudo apt-get install -q --fix-missing gcc-4.8 g++-4.8 + sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 + sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 + fi elif [ "$TRAVIS_OS_NAME" = osx ]; then xcode-select --install -- GitLab From ee34d63f1905d5ecc4246d83fae014579c12115a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Jun 2014 18:55:59 -0700 Subject: [PATCH 349/782] fix after rebase --- Rx/v2/src/rxcpp/rx-observable.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 0ec1123..b1b59fa 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -659,7 +659,7 @@ public: /// NOTE: multicast of a behavior /// auto publish(T first, composite_subscription cs = composite_subscription()) const - -> decltype(multicast(rxsub::behavior(first, cs))) { + -> decltype(EXPLICIT_THIS multicast(rxsub::behavior(first, cs))) { return multicast(rxsub::behavior(first, cs)); } -- GitLab From 07704df69b93414b638aa5433d6418df5c69e157 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Wed, 25 Jun 2014 17:31:55 +0400 Subject: [PATCH 350/782] Switch existing tests to use a new style Remove unnecessary local vars, typedefs, namespaces, and templates specialization from tests. --- Rx/v2/test/operators/buffer.cpp | 64 +- Rx/v2/test/operators/combine_latest.cpp | 79 +- Rx/v2/test/operators/concat.cpp | 159 +- Rx/v2/test/operators/concat_map.cpp | 91 +- .../test/operators/distinct_until_changed.cpp | 7 - Rx/v2/test/operators/filter.cpp | 320 ++-- Rx/v2/test/operators/flat_map.cpp | 330 ++-- Rx/v2/test/operators/lift.cpp | 174 +- Rx/v2/test/operators/map.cpp | 64 +- Rx/v2/test/operators/merge.cpp | 291 ++-- Rx/v2/test/operators/publish.cpp | 142 +- Rx/v2/test/operators/reduce.cpp | 8 - Rx/v2/test/operators/scan.cpp | 57 +- Rx/v2/test/operators/switch_on_next.cpp | 6 - Rx/v2/test/operators/take.cpp | 1447 +++++++---------- Rx/v2/test/sources/defer.cpp | 42 +- Rx/v2/test/sources/interval.cpp | 7 - Rx/v2/test/subjects/subject.cpp | 198 +-- 18 files changed, 1440 insertions(+), 2046 deletions(-) diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index a98e03e..2153f8d 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -1,48 +1,30 @@ #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("buffer count skip less", "[buffer][operators]"){ GIVEN("1 hot observable of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages> mv; - typedef rxn::subscription life; - - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - typedef mv::recorded_type vrecord; - auto von_next = mv::on_next; - auto von_completed = mv::on_completed; - auto vsubscribe = mv::subscribe; - - record messages1[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto xs = sc.make_hot_observable(messages1); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); WHEN("group each int with the next 2 ints"){ - auto res = w.start>( + auto res = w.start( [&]() { return xs .buffer(3, 1) @@ -52,23 +34,21 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ ); THEN("the output contains groups of ints"){ - vrecord items[] = { - von_next(230, rxu::to_vector(2, 3, 4)), - von_next(240, rxu::to_vector(3, 4, 5)), - von_next(250, rxu::to_vector(4, 5)), - von_next(250, rxu::to_vector(5)), - von_completed(250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + v_on.on_next(230, rxu::to_vector(2, 3, 4)), + v_on.on_next(240, rxu::to_vector(3, 4, 5)), + v_on.on_next(250, rxu::to_vector(4, 5)), + v_on.on_next(250, rxu::to_vector(5)), + v_on.on_completed(250) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the xs"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/combine_latest.cpp b/Rx/v2/test/operators/combine_latest.cpp index 8f40d22..fb13953 100644 --- a/Rx/v2/test/operators/combine_latest.cpp +++ b/Rx/v2/test/operators/combine_latest.cpp @@ -1,51 +1,35 @@ #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operators]"){ GIVEN("2 hot observables of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages> mo; - typedef rxn::subscription life; - - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; - record messages1[] = { - on_next(150, 1), - on_next(215, 2), - on_next(225, 4), - on_completed(230) - }; - auto o1 = sc.make_hot_observable(messages1); + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_completed(230) + }); - record messages2[] = { - on_next(150, 1), - on_next(220, 3), - on_next(230, 5), - on_next(235, 6), - on_next(240, 7), - on_completed(250) - }; - auto o2 = sc.make_hot_observable(messages2); + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(220, 3), + on.on_next(230, 5), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_completed(250) + }); WHEN("each int is combined with the latest from the other source"){ - auto res = w.start( + auto res = w.start( [&]() { return o2 .combine_latest([](int v2, int v1){return v2 + v1;}, o1) @@ -55,33 +39,30 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato ); THEN("the output contains combined ints"){ - record items[] = { - on_next(220, 2 + 3), - on_next(225, 4 + 3), - on_next(230, 4 + 5), - on_next(235, 4 + 6), - on_next(240, 4 + 7), - on_completed(250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(220, 2 + 3), + on.on_next(225, 4 + 3), + on.on_next(230, 4 + 5), + on.on_next(235, 4 + 6), + on.on_next(240, 4 + 7), + on.on_completed(250) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the o1"){ - life items[] = { - subscribe(200, 230) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); auto actual = o1.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the o2"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = o2.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 244d681..59a1813 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -1,15 +1,10 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" const int static_onnextcalls = 1000000; @@ -102,61 +97,46 @@ SCENARIO("concat completes", "[concat][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages> mo; - typedef rxn::subscription life; - - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - typedef mo::recorded_type orecord; - auto oon_next = mo::on_next; - auto oon_completed = mo::on_completed; - auto osubscribe = mo::subscribe; - - record messages1[] = { - on_next(10, 101), - on_next(20, 102), - on_next(110, 103), - on_next(120, 104), - on_next(210, 105), - on_next(220, 106), - on_completed(230) - }; - auto ys1 = sc.make_cold_observable(messages1); - - record messages2[] = { - on_next(10, 201), - on_next(20, 202), - on_next(30, 203), - on_next(40, 204), - on_completed(50) - }; - auto ys2 = sc.make_cold_observable(messages2); - - record messages3[] = { - on_next(10, 301), - on_next(20, 302), - on_next(30, 303), - on_next(40, 304), - on_next(120, 305), - on_completed(150) - }; - auto ys3 = sc.make_cold_observable(messages3); - - orecord omessages[] = { - oon_next(300, ys1), - oon_next(400, ys2), - oon_next(500, ys3), - oon_completed(600) - }; - auto xs = sc.make_hot_observable(omessages); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto ys2 = sc.make_cold_observable({ + on.on_next(10, 201), + on.on_next(20, 202), + on.on_next(30, 203), + on.on_next(40, 204), + on.on_completed(50) + }); + + auto ys3 = sc.make_cold_observable({ + on.on_next(10, 301), + on.on_next(20, 302), + on.on_next(30, 303), + on.on_next(40, 304), + on.on_next(120, 305), + on.on_completed(150) + }); + + auto xs = sc.make_hot_observable({ + o_on.on_next(300, ys1), + o_on.on_next(400, ys2), + o_on.on_next(500, ys3), + o_on.on_completed(600) + }); WHEN("each int is merged"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .concat() @@ -166,61 +146,56 @@ SCENARIO("concat completes", "[concat][join][operators]"){ ); THEN("the output contains merged ints"){ - record items[] = { - on_next(310, 101), - on_next(320, 102), - on_next(410, 103), - on_next(420, 104), - on_next(510, 105), - on_next(520, 106), - on_next(540, 201), - on_next(550, 202), - on_next(560, 203), - on_next(570, 204), - on_next(590, 301), - on_next(600, 302), - on_next(610, 303), - on_next(620, 304), - on_next(700, 305), - on_completed(730) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 103), + on.on_next(420, 104), + on.on_next(510, 105), + on.on_next(520, 106), + on.on_next(540, 201), + on.on_next(550, 202), + on.on_next(560, 203), + on.on_next(570, 204), + on.on_next(590, 301), + on.on_next(600, 302), + on.on_next(610, 303), + on.on_next(620, 304), + on.on_next(700, 305), + on.on_completed(730) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ints"){ - life items[] = { - subscribe(200, 600) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys1"){ - life items[] = { - subscribe(300, 530) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(300, 530) + }); auto actual = ys1.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys2"){ - life items[] = { - subscribe(530, 580) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(530, 580) + }); auto actual = ys2.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys3"){ - life items[] = { - subscribe(580, 730) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(580, 730) + }); auto actual = ys3.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index f04e0cc..c05fb18 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -1,15 +1,10 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" static const int static_tripletCount = 100; @@ -185,39 +180,26 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages ms; - typedef rxn::subscription life; - - typedef m::recorded_type irecord; - auto ion_next = m::on_next; - auto ion_completed = m::on_completed; - auto isubscribe = m::subscribe; - - typedef ms::recorded_type srecord; - auto son_next = ms::on_next; - auto son_completed = ms::on_completed; - auto ssubscribe = ms::subscribe; - - irecord int_messages[] = { - ion_next(100, 4), - ion_next(200, 2), - ion_completed(500) - }; - auto xs = sc.make_cold_observable(int_messages); - - srecord string_messages[] = { - son_next(50, "foo"), - son_next(100, "bar"), - son_next(150, "baz"), - son_next(200, "qux"), - son_completed(250) - }; - auto ys = sc.make_cold_observable(string_messages); + const rxsc::test::messages i_on; + const rxsc::test::messages s_on; + + auto xs = sc.make_cold_observable({ + i_on.on_next(100, 4), + i_on.on_next(200, 2), + i_on.on_completed(500) + }); + + auto ys = sc.make_cold_observable({ + s_on.on_next(50, "foo"), + s_on.on_next(100, "bar"), + s_on.on_next(150, "baz"), + s_on.on_next(200, "qux"), + s_on.on_completed(250) + }); WHEN("each int is mapped to the strings"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .concat_map( @@ -231,37 +213,34 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - srecord items[] = { - son_next(350, "foo"), - son_next(400, "bar"), - son_next(450, "baz"), - son_next(500, "qux"), - son_next(600, "foo"), - son_next(650, "bar"), - son_next(700, "baz"), - son_next(750, "qux"), - son_completed(800) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.on_next(350, "foo"), + s_on.on_next(400, "bar"), + s_on.on_next(450, "baz"), + s_on.on_next(500, "qux"), + s_on.on_next(600, "foo"), + s_on.on_next(650, "bar"), + s_on.on_next(700, "baz"), + s_on.on_next(750, "qux"), + s_on.on_completed(800) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ints"){ - life items[] = { - isubscribe(200, 700) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + i_on.subscribe(200, 700) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there were 2 subscription and unsubscription to the strings"){ - life items[] = { - ssubscribe(300, 550), - ssubscribe(550, 800) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.subscribe(300, 550), + s_on.subscribe(550, 800) + }); auto actual = ys.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/distinct_until_changed.cpp b/Rx/v2/test/operators/distinct_until_changed.cpp index 2639574..7df96ee 100644 --- a/Rx/v2/test/operators/distinct_until_changed.cpp +++ b/Rx/v2/test/operators/distinct_until_changed.cpp @@ -1,15 +1,8 @@ #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("distinct_until_changed - some changes", "[distinct_until_changed][operators]"){ diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index 3e9e61d..4d56dfa 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -1,18 +1,12 @@ - #define RXCPP_USE_OBSERVABLE_MEMBERS 1 #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" namespace { @@ -32,37 +26,30 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600), - on_next(610, 12), - on_error(620, std::runtime_error("error in unsubscribed stream")), - on_completed(630) - }; - auto xs = sc.make_hot_observable(messages); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600), + on.on_next(610, 12), + on.on_error(620, std::runtime_error("error in unsubscribed stream")), + on.on_completed(630) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [&xs, &invoked]() { #if 0 && RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -88,23 +75,21 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ } ); THEN("the output only contains primes"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7), - on_next(580, 11), - on_completed(600) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7), + on.on_next(580, 11), + on.on_completed(600) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 600) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -121,34 +106,28 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [&xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -172,21 +151,19 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ ); THEN("the output only contains primes that arrived before disposal"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -202,40 +179,33 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; std::runtime_error ex("filter on_error from source"); - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_error(600, ex), - on_next(610, 12), - on_error(620, std::runtime_error("error in unsubscribed stream")), - on_completed(630) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_error(600, ex), + on.on_next(610, 12), + on.on_error(620, std::runtime_error("error in unsubscribed stream")), + on.on_completed(630) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -258,23 +228,21 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ ); THEN("the output only contains primes"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7), - on_next(580, 11), - on_error(600, ex), - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7), + on.on_next(580, 11), + on.on_error(600, ex), + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 600) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -290,40 +258,33 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; std::runtime_error ex("filter predicate error"); - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600), - on_next(610, 12), - on_error(620, std::runtime_error("error in unsubscribed stream")), - on_completed(630) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600), + on.on_next(610, 12), + on.on_error(620, std::runtime_error("error in unsubscribed stream")), + on.on_completed(630) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [ex, xs, &invoked]() { #if RXCPP_USE_OBSERVABLE_MEMBERS return xs @@ -352,21 +313,19 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ ); THEN("the output only contains primes"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_error(380, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_error(380, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 380) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 380) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -382,34 +341,27 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600), - on_next(610, 12), - on_error(620, std::exception()), - on_completed(630) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600), + on.on_next(610, 12), + on.on_error(620, std::exception()), + on.on_completed(630) + }); auto res = w.make_subscriber(); @@ -449,21 +401,19 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") w.start(); THEN("the output only contains primes"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 450) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 450) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index c0a9b60..0179909 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -1,15 +1,10 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" static const int static_tripletCount = 100; @@ -222,41 +217,28 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages ms; - typedef rxn::subscription life; - - typedef m::recorded_type irecord; - auto ion_next = m::on_next; - auto ion_completed = m::on_completed; - auto isubscribe = m::subscribe; - - typedef ms::recorded_type srecord; - auto son_next = ms::on_next; - auto son_completed = ms::on_completed; - auto ssubscribe = ms::subscribe; - - irecord int_messages[] = { - ion_next(100, 4), - ion_next(200, 2), - ion_next(300, 3), - ion_next(400, 1), - ion_completed(500) - }; - auto xs = sc.make_cold_observable(int_messages); - - srecord string_messages[] = { - son_next(50, "foo"), - son_next(100, "bar"), - son_next(150, "baz"), - son_next(200, "qux"), - son_completed(250) - }; - auto ys = sc.make_cold_observable(string_messages); + const rxsc::test::messages i_on; + const rxsc::test::messages s_on; + + auto xs = sc.make_cold_observable({ + i_on.on_next(100, 4), + i_on.on_next(200, 2), + i_on.on_next(300, 3), + i_on.on_next(400, 1), + i_on.on_completed(500) + }); + + auto ys = sc.make_cold_observable({ + s_on.on_next(50, "foo"), + s_on.on_next(100, "bar"), + s_on.on_next(150, "baz"), + s_on.on_next(200, "qux"), + s_on.on_completed(250) + }); WHEN("each int is mapped to the strings"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .flat_map( @@ -270,47 +252,44 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - srecord items[] = { - son_next(350, "foo"), - son_next(400, "bar"), - son_next(450, "baz"), - son_next(450, "foo"), - son_next(500, "qux"), - son_next(500, "bar"), - son_next(550, "baz"), - son_next(550, "foo"), - son_next(600, "qux"), - son_next(600, "bar"), - son_next(650, "baz"), - son_next(650, "foo"), - son_next(700, "qux"), - son_next(700, "bar"), - son_next(750, "baz"), - son_next(800, "qux"), - son_completed(850) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.on_next(350, "foo"), + s_on.on_next(400, "bar"), + s_on.on_next(450, "baz"), + s_on.on_next(450, "foo"), + s_on.on_next(500, "qux"), + s_on.on_next(500, "bar"), + s_on.on_next(550, "baz"), + s_on.on_next(550, "foo"), + s_on.on_next(600, "qux"), + s_on.on_next(600, "bar"), + s_on.on_next(650, "baz"), + s_on.on_next(650, "foo"), + s_on.on_next(700, "qux"), + s_on.on_next(700, "bar"), + s_on.on_next(750, "baz"), + s_on.on_next(800, "qux"), + s_on.on_completed(850) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ints"){ - life items[] = { - isubscribe(200, 700) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + i_on.subscribe(200, 700) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there were four subscription and unsubscription to the strings"){ - life items[] = { - ssubscribe(300, 550), - ssubscribe(400, 650), - ssubscribe(500, 750), - ssubscribe(600, 850) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.subscribe(300, 550), + s_on.subscribe(400, 650), + s_on.subscribe(500, 750), + s_on.subscribe(600, 850) + }); auto actual = ys.subscriptions(); REQUIRE(required == actual); } @@ -323,41 +302,29 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages ms; - typedef rxn::subscription life; - - typedef m::recorded_type irecord; - auto ion_next = m::on_next; - auto isubscribe = m::subscribe; - - typedef ms::recorded_type srecord; - auto son_next = ms::on_next; - auto son_completed = ms::on_completed; - auto ssubscribe = ms::subscribe; - - irecord int_messages[] = { - ion_next(100, 4), - ion_next(200, 2), - ion_next(300, 3), - ion_next(400, 1), - ion_next(500, 5), - ion_next(700, 0) - }; - auto xs = sc.make_cold_observable(int_messages); - - srecord string_messages[] = { - son_next(50, "foo"), - son_next(100, "bar"), - son_next(150, "baz"), - son_next(200, "qux"), - son_completed(250) - }; - auto ys = sc.make_cold_observable(string_messages); + const rxsc::test::messages i_on; + const rxsc::test::messages s_on; + + auto xs = sc.make_cold_observable({ + i_on.on_next(100, 4), + i_on.on_next(200, 2), + i_on.on_next(300, 3), + i_on.on_next(400, 1), + i_on.on_next(500, 5), + i_on.on_next(700, 0) + }); + + auto ys = sc.make_cold_observable({ + s_on.on_next(50, "foo"), + s_on.on_next(100, "bar"), + s_on.on_next(150, "baz"), + s_on.on_next(200, "qux"), + s_on.on_completed(250) + }); WHEN("each int is mapped to the strings"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) @@ -367,53 +334,50 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - srecord items[] = { - son_next(350, "foo"), - son_next(400, "bar"), - son_next(450, "baz"), - son_next(450, "foo"), - son_next(500, "qux"), - son_next(500, "bar"), - son_next(550, "baz"), - son_next(550, "foo"), - son_next(600, "qux"), - son_next(600, "bar"), - son_next(650, "baz"), - son_next(650, "foo"), - son_next(700, "qux"), - son_next(700, "bar"), - son_next(750, "baz"), - son_next(750, "foo"), - son_next(800, "qux"), - son_next(800, "bar"), - son_next(850, "baz"), - son_next(900, "qux"), - son_next(950, "foo") - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.on_next(350, "foo"), + s_on.on_next(400, "bar"), + s_on.on_next(450, "baz"), + s_on.on_next(450, "foo"), + s_on.on_next(500, "qux"), + s_on.on_next(500, "bar"), + s_on.on_next(550, "baz"), + s_on.on_next(550, "foo"), + s_on.on_next(600, "qux"), + s_on.on_next(600, "bar"), + s_on.on_next(650, "baz"), + s_on.on_next(650, "foo"), + s_on.on_next(700, "qux"), + s_on.on_next(700, "bar"), + s_on.on_next(750, "baz"), + s_on.on_next(750, "foo"), + s_on.on_next(800, "qux"), + s_on.on_next(800, "bar"), + s_on.on_next(850, "baz"), + s_on.on_next(900, "qux"), + s_on.on_next(950, "foo") + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ints"){ - life items[] = { - isubscribe(200, 1000) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + i_on.subscribe(200, 1000) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there were four subscription and unsubscription to the strings"){ - life items[] = { - ssubscribe(300, 550), - ssubscribe(400, 650), - ssubscribe(500, 750), - ssubscribe(600, 850), - ssubscribe(700, 950), - ssubscribe(900, 1000) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.subscribe(300, 550), + s_on.subscribe(400, 650), + s_on.subscribe(500, 750), + s_on.subscribe(600, 850), + s_on.subscribe(700, 950), + s_on.subscribe(900, 1000) + }); auto actual = ys.subscriptions(); REQUIRE(required == actual); } @@ -425,43 +389,30 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ GIVEN("two cold observables. one of ints. one of strings."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages ms; - typedef rxn::subscription life; - - typedef m::recorded_type irecord; - auto ion_next = m::on_next; - auto ion_completed = m::on_completed; - auto isubscribe = m::subscribe; - - typedef ms::recorded_type srecord; - auto son_next = ms::on_next; - auto son_error = ms::on_error; - auto ssubscribe = ms::subscribe; - - irecord int_messages[] = { - ion_next(100, 4), - ion_next(200, 2), - ion_next(300, 3), - ion_next(400, 1), - ion_completed(500) - }; - auto xs = sc.make_cold_observable(int_messages); + const rxsc::test::messages i_on; + const rxsc::test::messages s_on; + + auto xs = sc.make_cold_observable({ + i_on.on_next(100, 4), + i_on.on_next(200, 2), + i_on.on_next(300, 3), + i_on.on_next(400, 1), + i_on.on_completed(500) + }); std::runtime_error ex("filter on_error from inner source"); - srecord string_messages[] = { - son_next(55, "foo"), - son_next(104, "bar"), - son_next(153, "baz"), - son_next(202, "qux"), - son_error(301, ex) - }; - auto ys = sc.make_cold_observable(string_messages); + auto ys = sc.make_cold_observable({ + s_on.on_next(55, "foo"), + s_on.on_next(104, "bar"), + s_on.on_next(153, "baz"), + s_on.on_next(202, "qux"), + s_on.on_error(301, ex) + }); WHEN("each int is mapped to the strings"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .flat_map([&](int){return ys;}, [](int, std::string s){return s;}) @@ -471,39 +422,36 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ ); THEN("the output contains strings repeated for each int"){ - srecord items[] = { - son_next(355, "foo"), - son_next(404, "bar"), - son_next(453, "baz"), - son_next(455, "foo"), - son_next(502, "qux"), - son_next(504, "bar"), - son_next(553, "baz"), - son_next(555, "foo"), - son_error(601, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.on_next(355, "foo"), + s_on.on_next(404, "bar"), + s_on.on_next(453, "baz"), + s_on.on_next(455, "foo"), + s_on.on_next(502, "qux"), + s_on.on_next(504, "bar"), + s_on.on_next(553, "baz"), + s_on.on_next(555, "foo"), + s_on.on_error(601, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ints"){ - life items[] = { - isubscribe(200, 601) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + i_on.subscribe(200, 601) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there were four subscription and unsubscription to the strings"){ - life items[] = { - ssubscribe(300, 601), - ssubscribe(400, 601), - ssubscribe(500, 601), - ssubscribe(600, 601) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + s_on.subscribe(300, 601), + s_on.subscribe(400, 601), + s_on.subscribe(500, 601), + s_on.subscribe(600, 601) + }); auto actual = ys.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/lift.cpp b/Rx/v2/test/operators/lift.cpp index 6952d44..7cf35b6 100644 --- a/Rx/v2/test/operators/lift.cpp +++ b/Rx/v2/test/operators/lift.cpp @@ -1,18 +1,12 @@ - #define RXCPP_USE_OBSERVABLE_MEMBERS 1 #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" namespace detail { @@ -102,34 +96,28 @@ SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]" GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [&xs, &invoked]() { return xs .lift(liftfilter([&invoked](int x) { @@ -143,21 +131,19 @@ SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]" ); THEN("the output only contains primes that arrived before disposal"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -173,34 +159,28 @@ SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][stre GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [&xs, &invoked]() { return xs >> liftfilter([&invoked](int x) { @@ -214,21 +194,19 @@ SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][stre ); THEN("the output only contains primes that arrived before disposal"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -244,34 +222,28 @@ SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(110, 1), - on_next(180, 2), - on_next(230, 3), - on_next(270, 4), - on_next(340, 5), - on_next(380, 6), - on_next(390, 7), - on_next(450, 8), - on_next(470, 9), - on_next(560, 10), - on_next(580, 11), - on_completed(600) - }; - auto xs = sc.make_hot_observable(rxu::to_vector(messages)); + auto xs = sc.make_hot_observable({ + on.on_next(110, 1), + on.on_next(180, 2), + on.on_next(230, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(380, 6), + on.on_next(390, 7), + on.on_next(450, 8), + on.on_next(470, 9), + on.on_next(560, 10), + on.on_next(580, 11), + on.on_completed(600) + }); WHEN("filtered to ints that are primes"){ - auto res = w.start( + auto res = w.start( [&xs, &invoked]() { auto predicate = [&](int x){ invoked++; @@ -298,21 +270,19 @@ SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][ ); THEN("the output only contains primes that arrived before disposal"){ - record items[] = { - on_next(230, 3), - on_next(340, 5), - on_next(390, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 3), + on.on_next(340, 5), + on.on_next(390, 7) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/map.cpp b/Rx/v2/test/operators/map.cpp index db53387..4491511 100644 --- a/Rx/v2/test/operators/map.cpp +++ b/Rx/v2/test/operators/map.cpp @@ -1,48 +1,32 @@ - #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("map stops on completion", "[map][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - + const rxsc::test::messages on; long invoked = 0; - record messages[] = { - on_next(180, 1), - on_next(210, 2), - on_next(240, 3), - on_next(290, 4), - on_next(350, 5), - on_completed(400), - on_next(410, -1), - on_completed(420), - on_error(430, std::runtime_error("error on unsubscribed stream")) - }; - auto xs = sc.make_hot_observable(messages); + auto xs = sc.make_hot_observable({ + on.on_next(180, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(290, 4), + on.on_next(350, 5), + on.on_completed(400), + on.on_next(410, -1), + on.on_completed(420), + on.on_error(430, std::runtime_error("error on unsubscribed stream")) + }); WHEN("mapped to ints that are one larger"){ - auto res = w.start( + auto res = w.start( [xs, &invoked]() { return xs .map([&invoked](int x) { @@ -55,23 +39,21 @@ SCENARIO("map stops on completion", "[map][operators]"){ ); THEN("the output stops on completion"){ - record items[] = { - on_next(210, 3), - on_next(240, 4), - on_next(290, 5), - on_next(350, 6), - on_completed(400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 3), + on.on_next(240, 4), + on.on_next(290, 5), + on.on_next(350, 6), + on.on_completed(400) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 1e96068..d287fe0 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -1,15 +1,10 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" const int static_onnextcalls = 1000000; @@ -103,61 +98,46 @@ SCENARIO("merge completes", "[merge][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages> mo; - typedef rxn::subscription life; - - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - typedef mo::recorded_type orecord; - auto oon_next = mo::on_next; - auto oon_completed = mo::on_completed; - auto osubscribe = mo::subscribe; - - record messages1[] = { - on_next(10, 101), - on_next(20, 102), - on_next(110, 103), - on_next(120, 104), - on_next(210, 105), - on_next(220, 106), - on_completed(230) - }; - auto ys1 = sc.make_cold_observable(messages1); - - record messages2[] = { - on_next(10, 201), - on_next(20, 202), - on_next(30, 203), - on_next(40, 204), - on_completed(50) - }; - auto ys2 = sc.make_cold_observable(messages2); - - record messages3[] = { - on_next(10, 301), - on_next(20, 302), - on_next(30, 303), - on_next(40, 304), - on_next(120, 305), - on_completed(150) - }; - auto ys3 = sc.make_cold_observable(messages3); - - orecord omessages[] = { - oon_next(300, ys1), - oon_next(400, ys2), - oon_next(500, ys3), - oon_completed(600) - }; - auto xs = sc.make_hot_observable(omessages); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto ys2 = sc.make_cold_observable({ + on.on_next(10, 201), + on.on_next(20, 202), + on.on_next(30, 203), + on.on_next(40, 204), + on.on_completed(50) + }); + + auto ys3 = sc.make_cold_observable({ + on.on_next(10, 301), + on.on_next(20, 302), + on.on_next(30, 303), + on.on_next(40, 304), + on.on_next(120, 305), + on.on_completed(150) + }); + + auto xs = sc.make_hot_observable({ + o_on.on_next(300, ys1), + o_on.on_next(400, ys2), + o_on.on_next(500, ys3), + o_on.on_completed(600) + }); WHEN("each int is merged"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .merge() @@ -167,61 +147,56 @@ SCENARIO("merge completes", "[merge][join][operators]"){ ); THEN("the output contains merged ints"){ - record items[] = { - on_next(310, 101), - on_next(320, 102), - on_next(410, 103), - on_next(410, 201), - on_next(420, 104), - on_next(420, 202), - on_next(430, 203), - on_next(440, 204), - on_next(510, 105), - on_next(510, 301), - on_next(520, 106), - on_next(520, 302), - on_next(530, 303), - on_next(540, 304), - on_next(620, 305), - on_completed(650) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 103), + on.on_next(410, 201), + on.on_next(420, 104), + on.on_next(420, 202), + on.on_next(430, 203), + on.on_next(440, 204), + on.on_next(510, 105), + on.on_next(510, 301), + on.on_next(520, 106), + on.on_next(520, 302), + on.on_next(530, 303), + on.on_next(540, 304), + on.on_next(620, 305), + on.on_completed(650) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the xs"){ - life items[] = { - subscribe(200, 600) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys1"){ - life items[] = { - subscribe(300, 530) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(300, 530) + }); auto actual = ys1.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys2"){ - life items[] = { - subscribe(400, 450) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(400, 450) + }); auto actual = ys2.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys3"){ - life items[] = { - subscribe(500, 650) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(500, 650) + }); auto actual = ys3.subscriptions(); REQUIRE(required == actual); } @@ -233,53 +208,39 @@ SCENARIO("variadic merge completes", "[merge][join][operators]"){ GIVEN("1 hot observable with 3 cold observables of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxsc::test::messages> mo; - typedef rxn::subscription life; - - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - typedef mo::recorded_type orecord; - auto oon_next = mo::on_next; - auto oon_completed = mo::on_completed; - auto osubscribe = mo::subscribe; - - record messages1[] = { - on_next(10, 101), - on_next(20, 102), - on_next(110, 103), - on_next(120, 104), - on_next(210, 105), - on_next(220, 106), - on_completed(230) - }; - auto ys1 = sc.make_cold_observable(messages1); - - record messages2[] = { - on_next(10, 201), - on_next(20, 202), - on_next(30, 203), - on_next(40, 204), - on_completed(50) - }; - auto ys2 = sc.make_cold_observable(messages2); - - record messages3[] = { - on_next(10, 301), - on_next(20, 302), - on_next(30, 303), - on_next(40, 304), - on_next(120, 305), - on_completed(150) - }; - auto ys3 = sc.make_cold_observable(messages3); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto ys2 = sc.make_cold_observable({ + on.on_next(10, 201), + on.on_next(20, 202), + on.on_next(30, 203), + on.on_next(40, 204), + on.on_completed(50) + }); + + auto ys3 = sc.make_cold_observable({ + on.on_next(10, 301), + on.on_next(20, 302), + on.on_next(30, 303), + on.on_next(40, 304), + on.on_next(120, 305), + on.on_completed(150) + }); WHEN("each int is merged"){ - auto res = w.start( + auto res = w.start( [&]() { return ys1 .merge(ys2, ys3); @@ -287,52 +248,48 @@ SCENARIO("variadic merge completes", "[merge][join][operators]"){ ); THEN("the output contains merged ints"){ - record items[] = { - on_next(210, 101), - on_next(210, 201), - on_next(210, 301), - on_next(220, 102), - on_next(220, 202), - on_next(220, 302), - on_next(230, 203), - on_next(230, 303), - on_next(240, 204), - on_next(240, 304), - on_next(310, 103), - on_next(320, 104), - on_next(320, 305), - on_next(410, 105), - on_next(420, 106), - on_completed(430) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 101), + on.on_next(210, 201), + on.on_next(210, 301), + on.on_next(220, 102), + on.on_next(220, 202), + on.on_next(220, 302), + on.on_next(230, 203), + on.on_next(230, 303), + on.on_next(240, 204), + on.on_next(240, 304), + on.on_next(310, 103), + on.on_next(320, 104), + on.on_next(320, 305), + on.on_next(410, 105), + on.on_next(420, 106), + on.on_completed(430) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys1"){ - life items[] = { - subscribe(200, 430) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 430) + }); auto actual = ys1.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys2"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = ys2.subscriptions(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to the ys3"){ - life items[] = { - subscribe(200, 350) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 350) + }); auto actual = ys3.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 7c6fd5f..5972ac2 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -1,15 +1,10 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" @@ -51,30 +46,24 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ GIVEN("a test hot observable of longs"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record messages[] = { - on_next(110, 7), - on_next(220, 3), - on_next(280, 4), - on_next(290, 1), - on_next(340, 8), - on_next(360, 5), - on_next(370, 6), - on_next(390, 7), - on_next(410, 13), - on_next(430, 2), - on_next(450, 9), - on_next(520, 11), - on_next(560, 20), - on_completed(600) - }; - auto xs = sc.make_hot_observable(messages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(110, 7), + on.on_next(220, 3), + on.on_next(280, 4), + on.on_next(290, 1), + on.on_next(340, 8), + on.on_next(360, 5), + on.on_next(370, 6), + on.on_next(390, 7), + on.on_next(410, 13), + on.on_next(430, 2), + on.on_next(450, 9), + on.on_next(520, 11), + on.on_next(560, 20), + on.on_completed(600) + }); auto res = w.make_subscriber(); @@ -140,25 +129,23 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ w.start(); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(340, 8), - on_next(360, 5), - on_next(370, 6), - on_next(390, 7), - on_next(520, 11) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(340, 8), + on.on_next(360, 5), + on.on_next(370, 6), + on.on_next(390, 7), + on.on_next(520, 11) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there were 3 subscription/unsubscription"){ - life items[] = { - subscribe(300, 400), - subscribe(500, 550), - subscribe(650, 800) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(300, 400), + on.subscribe(500, 550), + on.subscribe(650, 800) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -172,33 +159,26 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ GIVEN("a test hot observable of longs"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; std::runtime_error ex("publish on_error"); - record messages[] = { - on_next(110, 7), - on_next(220, 3), - on_next(280, 4), - on_next(290, 1), - on_next(340, 8), - on_next(360, 5), - on_next(370, 6), - on_next(390, 7), - on_next(410, 13), - on_next(430, 2), - on_next(450, 9), - on_next(520, 11), - on_next(560, 20), - on_error(600, ex) - }; - auto xs = sc.make_hot_observable(messages); + auto xs = sc.make_hot_observable({ + on.on_next(110, 7), + on.on_next(220, 3), + on.on_next(280, 4), + on.on_next(290, 1), + on.on_next(340, 8), + on.on_next(360, 5), + on.on_next(370, 6), + on.on_next(390, 7), + on.on_next(410, 13), + on.on_next(430, 2), + on.on_next(450, 9), + on.on_next(520, 11), + on.on_next(560, 20), + on.on_error(600, ex) + }); auto res = w.make_subscriber(); @@ -250,26 +230,24 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ w.start(); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(340, 8), - on_next(360, 5), - on_next(370, 6), - on_next(390, 7), - on_next(520, 11), - on_next(560, 20), - on_error(600, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(340, 8), + on.on_next(360, 5), + on.on_next(370, 6), + on.on_next(390, 7), + on.on_next(520, 11), + on.on_next(560, 20), + on.on_error(600, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there were 3 subscription/unsubscription"){ - life items[] = { - subscribe(300, 400), - subscribe(500, 600) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(300, 400), + on.subscribe(500, 600) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/reduce.cpp b/Rx/v2/test/operators/reduce.cpp index a45354b..4872ca5 100644 --- a/Rx/v2/test/operators/reduce.cpp +++ b/Rx/v2/test/operators/reduce.cpp @@ -1,16 +1,8 @@ - #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("reduce some data with seed", "[reduce][operators]"){ diff --git a/Rx/v2/test/operators/scan.cpp b/Rx/v2/test/operators/scan.cpp index 27ab1c5..3615ff2 100644 --- a/Rx/v2/test/operators/scan.cpp +++ b/Rx/v2/test/operators/scan.cpp @@ -1,45 +1,30 @@ - #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("scan some data with seed", "[scan][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; int seed = 1; - record messages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto xs = sc.make_hot_observable(messages); + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); WHEN("mapped to ints that are one larger"){ - auto res = w.start( + auto res = w.start( [&]() { return xs .scan(seed, [](int sum, int x) { @@ -51,23 +36,21 @@ SCENARIO("scan some data with seed", "[scan][operators]"){ ); THEN("the output stops on completion"){ - record items[] = { - on_next(210, seed + 2), - on_next(220, seed + 2 + 3), - on_next(230, seed + 2 + 3 + 4), - on_next(240, seed + 2 + 3 + 4 + 5), - on_completed(250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, seed + 2), + on.on_next(220, seed + 2 + 3), + on.on_next(230, seed + 2 + 3 + 4), + on.on_next(240, seed + 2 + 3 + 4 + 5), + on.on_completed(250) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/switch_on_next.cpp b/Rx/v2/test/operators/switch_on_next.cpp index f6f70b0..7831d48 100644 --- a/Rx/v2/test/operators/switch_on_next.cpp +++ b/Rx/v2/test/operators/switch_on_next.cpp @@ -1,15 +1,9 @@ #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("switch_on_next - some changes", "[switch_on_next][operators]"){ diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index 26582f1..f87b9df 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -1,15 +1,8 @@ #include "rxcpp/rx.hpp" -namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("take 2", "[take][operators]"){ @@ -64,40 +57,34 @@ SCENARIO("take, complete after", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_completed(690) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); WHEN("20 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(20) @@ -107,36 +94,34 @@ SCENARIO("take, complete after", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_completed(690) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 690) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -149,41 +134,34 @@ SCENARIO("take, complete same", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_completed(690) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); WHEN("17 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(17) @@ -193,36 +171,34 @@ SCENARIO("take, complete same", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_completed(630) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(630) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 630) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 630) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -235,41 +211,34 @@ SCENARIO("take, complete before", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_completed(690) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); WHEN("10 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(10) @@ -279,29 +248,27 @@ SCENARIO("take, complete before", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_completed(415) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_completed(415) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 415) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 415) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -314,43 +281,36 @@ SCENARIO("take, error after", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; std::runtime_error ex("take on_error from source"); - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_error(690, ex) - }; - auto xs = sc.make_hot_observable(xmessages); + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, ex) + }); WHEN("20 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(20) @@ -360,36 +320,34 @@ SCENARIO("take, error after", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_error(690, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 690) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -402,41 +360,34 @@ SCENARIO("take, error same", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_error(690, std::runtime_error("error in unsubscribed stream")) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, std::runtime_error("error in unsubscribed stream")) + }); WHEN("17 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(17) @@ -446,36 +397,34 @@ SCENARIO("take, error same", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_completed(630) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(630) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 630) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 630) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -488,41 +437,34 @@ SCENARIO("take, error before", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10), - on_error(690, std::runtime_error("error in unsubscribed stream")) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, std::runtime_error("error in unsubscribed stream")) + }); WHEN("3 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(3) @@ -532,22 +474,20 @@ SCENARIO("take, error before", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_completed(270) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_completed(270) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 270) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 270) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -560,40 +500,33 @@ SCENARIO("take, dispose before", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10) + }); WHEN("3 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(3) @@ -604,20 +537,18 @@ SCENARIO("take, dispose before", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -630,40 +561,33 @@ SCENARIO("take, dispose after", "[take][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(70, 6), - on_next(150, 4), - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_next(280, 1), - on_next(300, -1), - on_next(310, 3), - on_next(340, 8), - on_next(370, 11), - on_next(410, 15), - on_next(415, 16), - on_next(460, 72), - on_next(510, 76), - on_next(560, 32), - on_next(570, -100), - on_next(580, -3), - on_next(590, 5), - on_next(630, 10) - }; - auto xs = sc.make_hot_observable(xmessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10) + }); WHEN("3 values are taken"){ - auto res = w.start( + auto res = w.start( [xs]() { return xs .take(3) @@ -674,22 +598,20 @@ SCENARIO("take, dispose after", "[take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 9), - on_next(230, 13), - on_next(270, 7), - on_completed(270) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_completed(270) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 270) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 270) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -704,34 +626,26 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record xmessages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto xs = sc.make_hot_observable(xmessages); - - record ymessages[] = { - on_next(150, 1), - on_next(225, 99), - on_completed(230) - }; - auto ys = sc.make_hot_observable(ymessages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto ys = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 99), + on.on_completed(230) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [xs, ys]() { return xs .take_until(ys) @@ -741,30 +655,27 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 2), - on_next(220, 3), - on_completed(225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_completed(225) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = ys.subscriptions(); REQUIRE(required == actual); } @@ -777,34 +688,26 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1), - on_next(225, 99), - on_completed(230) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 99), + on.on_completed(230) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -814,30 +717,27 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 2), - on_next(220, 3), - on_completed(225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_completed(225) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -850,35 +750,27 @@ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]") GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; std::runtime_error ex("take_until on_error from source"); - record lmessages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1), - on_error(225, ex) - }; - auto r = sc.make_hot_observable(rmessages); + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -888,30 +780,27 @@ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]") ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 2), - on_next(220, 3), - on_error(225, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_error(225, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -924,33 +813,25 @@ SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1), - on_completed(225) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(225) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -960,32 +841,29 @@ SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -998,32 +876,24 @@ SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1), - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1033,32 +903,29 @@ SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(210, 2), - on_next(220, 3), - on_next(230, 4), - on_next(240, 5), - on_completed(250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 250) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -1071,29 +938,21 @@ SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1), - on_next(225, 2), //! - on_completed(250) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 2), //! + on.on_completed(250) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1103,28 +962,25 @@ SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_completed(225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_completed(225) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -1137,30 +993,22 @@ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; std::runtime_error ex("take_until on_error from source"); - record lmessages[] = { - on_next(150, 1) - }; - auto l = sc.make_hot_observable(lmessages); + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); - record rmessages[] = { - on_next(150, 1), - on_error(225, ex) - }; - auto r = sc.make_hot_observable(rmessages); + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1170,28 +1018,25 @@ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_error(225, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_error(225, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -1204,28 +1049,20 @@ SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1), - on_completed(225) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(225) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1235,25 +1072,23 @@ SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - auto required = std::vector(); + auto required = std::vector::recorded_type>(); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -1266,27 +1101,19 @@ SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1296,25 +1123,23 @@ SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - auto required = std::vector(); + auto required = std::vector::recorded_type>(); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 1000) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 1000) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -1327,31 +1152,23 @@ SCENARIO("take_until, preempt before first produced", "[take_until][take][operat GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; - - record lmessages[] = { - on_next(150, 1), - on_next(230, 2), - on_completed(240) - }; - auto l = sc.make_hot_observable(lmessages); - - record rmessages[] = { - on_next(150, 1), - on_next(210, 2), //! - on_completed(220) - }; - auto r = sc.make_hot_observable(rmessages); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(230, 2), + on.on_completed(240) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), //! + on.on_completed(220) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1361,28 +1178,25 @@ SCENARIO("take_until, preempt before first produced", "[take_until][take][operat ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_completed(210) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_completed(210) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 210) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 210) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } @@ -1395,33 +1209,25 @@ SCENARIO("take_until, preempt before first produced, remain silent and proper un GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; bool sourceNotDisposed = false; - record lmessages[] = { - on_next(150, 1), - on_error(215, std::runtime_error("error in unsubscribed stream")), // should not come - on_completed(240) - }; - auto l = sc.make_hot_observable(lmessages); + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(215, std::runtime_error("error in unsubscribed stream")), // should not come + on.on_completed(240) + }); - record rmessages[] = { - on_next(150, 1), - on_next(210, 2), //! - on_completed(220) - }; - auto r = sc.make_hot_observable(rmessages); + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), //! + on.on_completed(220) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r, &sourceNotDisposed]() { return l .map([&sourceNotDisposed](int v){sourceNotDisposed = true; return v;}) @@ -1432,10 +1238,9 @@ SCENARIO("take_until, preempt before first produced, remain silent and proper un ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_completed(210) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_completed(210) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -1454,33 +1259,25 @@ SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal" GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; bool signalNotDisposed = false; - record lmessages[] = { - on_next(150, 1), - on_next(230, 2), - on_completed(240) - }; - auto l = sc.make_hot_observable(lmessages); + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(230, 2), + on.on_completed(240) + }); - record rmessages[] = { - on_next(150, 1), - on_next(250, 2), - on_completed(260) - }; - auto r = sc.make_hot_observable(rmessages); + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(250, 2), + on.on_completed(260) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r, &signalNotDisposed]() { return l .take_until(r @@ -1491,11 +1288,10 @@ SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal" ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_next(230, 2), - on_completed(240) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(230, 2), + on.on_completed(240) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -1514,31 +1310,23 @@ SCENARIO("take_until, error some", "[take_until][take][operators]"){ GIVEN("2 sources"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; std::runtime_error ex("take_until on_error from source"); - record lmessages[] = { - on_next(150, 1), - on_error(225, ex) - }; - auto l = sc.make_hot_observable(lmessages); + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); - record rmessages[] = { - on_next(150, 1), - on_next(240, 2) - }; - auto r = sc.make_hot_observable(rmessages); + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(240, 2) + }); WHEN("one is taken until the other emits a marble"){ - auto res = w.start( + auto res = w.start( [l, r]() { return l .take_until(r) @@ -1548,28 +1336,25 @@ SCENARIO("take_until, error some", "[take_until][take][operators]"){ ); THEN("the output only contains items sent while subscribed"){ - record items[] = { - on_error(225, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_error(225, ex) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the source"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = l.subscriptions(); REQUIRE(required == actual); } THEN("there was 1 subscription/unsubscription to the trigger"){ - life items[] = { - subscribe(200, 225) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); auto actual = r.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/sources/defer.cpp b/Rx/v2/test/sources/defer.cpp index 18d4e42..ea44b4d 100644 --- a/Rx/v2/test/sources/defer.cpp +++ b/Rx/v2/test/sources/defer.cpp @@ -1,29 +1,16 @@ - #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" SCENARIO("defer stops on completion", "[defer][operators]"){ GIVEN("a test cold observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - auto subscribe = m::subscribe; + const rxsc::test::messages on; long invoked = 0; @@ -37,16 +24,15 @@ SCENARIO("defer stops on completion", "[defer][operators]"){ auto error = rx::observable<>::error(std::exception_ptr()); auto runtimeerror = rx::observable<>::error(std::runtime_error("runtime")); - auto res = w.start( + auto res = w.start( [&]() { return rx::observable<>::defer( [&](){ invoked++; - record messages[] = { - on_next(100, sc.clock()), - on_completed(200) - }; - xs.reset(sc.make_cold_observable(messages)); + xs.reset(sc.make_cold_observable({ + on.on_next(100, sc.clock()), + on.on_completed(200) + })); return xs.get(); }) // forget type to workaround lambda deduction bug on msvc 2013 @@ -55,20 +41,18 @@ SCENARIO("defer stops on completion", "[defer][operators]"){ ); THEN("the output stops on completion"){ - record items[] = { - on_next(300, 200L), - on_completed(400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(300, 200L), + on.on_completed(400) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription"){ - life items[] = { - subscribe(200, 400) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); auto actual = xs.get().subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp index 63c6503..49d68e2 100644 --- a/Rx/v2/test/sources/interval.cpp +++ b/Rx/v2/test/sources/interval.cpp @@ -1,16 +1,9 @@ - #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; -namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 9664173..4d8faf7 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -1,18 +1,13 @@ - #define RXCPP_SUBJECT_TEST_ASYNC 1 #include "rxcpp/rx.hpp" namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxo=rxcpp::operators; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; namespace rxsub=rxcpp::subjects; -namespace rxn=rxcpp::notifications; #include "rxcpp/rx-test.hpp" -namespace rxt=rxcpp::test; - #include "catch.hpp" #include @@ -443,26 +438,22 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - - record messages[] = { - on_next(70, 1), - on_next(110, 2), - on_next(220, 3), - on_next(270, 4), - on_next(340, 5), - on_next(410, 6), - on_next(520, 7), - on_next(630, 8), - on_next(710, 9), - on_next(870, 10), - on_next(940, 11), - on_next(1020, 12) - }; - auto xs = sc.make_hot_observable(messages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 1), + on.on_next(110, 2), + on.on_next(220, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(410, 6), + on.on_next(520, 7), + on.on_next(630, 8), + on.on_next(710, 9), + on.on_next(870, 10), + on.on_next(940, 11), + on.on_next(1020, 12) + }); rxsub::subject s; @@ -502,32 +493,29 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ w.start(); THEN("result1 contains expected messages"){ - record items[] = { - on_next(340, 5), - on_next(410, 6), - on_next(520, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(340, 5), + on.on_next(410, 6), + on.on_next(520, 7) + }); auto actual = results1.get_observer().messages(); REQUIRE(required == actual); } THEN("result2 contains expected messages"){ - record items[] = { - on_next(410, 6), - on_next(520, 7), - on_next(630, 8) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(410, 6), + on.on_next(520, 7), + on.on_next(630, 8) + }); auto actual = results2.get_observer().messages(); REQUIRE(required == actual); } THEN("result3 contains expected messages"){ - record items[] = { - on_next(940, 11) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(940, 11) + }); auto actual = results3.get_observer().messages(); REQUIRE(required == actual); } @@ -541,27 +529,21 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; - - record messages[] = { - on_next(70, 1), - on_next(110, 2), - on_next(220, 3), - on_next(270, 4), - on_next(340, 5), - on_next(410, 6), - on_next(520, 7), - on_completed(630), - on_next(640, 9), - on_completed(650), - on_error(660, std::runtime_error("error on unsubscribed stream")) - }; - auto xs = sc.make_hot_observable(messages); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 1), + on.on_next(110, 2), + on.on_next(220, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(410, 6), + on.on_next(520, 7), + on.on_completed(630), + on.on_next(640, 9), + on.on_completed(650), + on.on_error(660, std::runtime_error("error on unsubscribed stream")) + }); rxsub::subject s; @@ -601,32 +583,29 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ w.start(); THEN("result1 contains expected messages"){ - record items[] = { - on_next(340, 5), - on_next(410, 6), - on_next(520, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(340, 5), + on.on_next(410, 6), + on.on_next(520, 7) + }); auto actual = results1.get_observer().messages(); REQUIRE(required == actual); } THEN("result2 contains expected messages"){ - record items[] = { - on_next(410, 6), - on_next(520, 7), - on_completed(630) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(410, 6), + on.on_next(520, 7), + on.on_completed(630) + }); auto actual = results2.get_observer().messages(); REQUIRE(required == actual); } THEN("result3 contains expected messages"){ - record items[] = { - on_completed(900) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_completed(900) + }); auto actual = results3.get_observer().messages(); REQUIRE(required == actual); } @@ -641,29 +620,23 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); - typedef rxsc::test::messages m; - typedef rxn::subscription life; - typedef m::recorded_type record; - auto on_next = m::on_next; - auto on_error = m::on_error; - auto on_completed = m::on_completed; + const rxsc::test::messages on; std::runtime_error ex("subject on_error in stream"); - record messages[] = { - on_next(70, 1), - on_next(110, 2), - on_next(220, 3), - on_next(270, 4), - on_next(340, 5), - on_next(410, 6), - on_next(520, 7), - on_error(630, ex), - on_next(640, 9), - on_completed(650), - on_error(660, std::runtime_error("error on unsubscribed stream")) - }; - auto xs = sc.make_hot_observable(messages); + auto xs = sc.make_hot_observable({ + on.on_next(70, 1), + on.on_next(110, 2), + on.on_next(220, 3), + on.on_next(270, 4), + on.on_next(340, 5), + on.on_next(410, 6), + on.on_next(520, 7), + on.on_error(630, ex), + on.on_next(640, 9), + on.on_completed(650), + on.on_error(660, std::runtime_error("error on unsubscribed stream")) + }); rxsub::subject s; @@ -703,32 +676,29 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ w.start(); THEN("result1 contains expected messages"){ - record items[] = { - on_next(340, 5), - on_next(410, 6), - on_next(520, 7) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(340, 5), + on.on_next(410, 6), + on.on_next(520, 7) + }); auto actual = results1.get_observer().messages(); REQUIRE(required == actual); } THEN("result2 contains expected messages"){ - record items[] = { - on_next(410, 6), - on_next(520, 7), - on_error(630, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_next(410, 6), + on.on_next(520, 7), + on.on_error(630, ex) + }); auto actual = results2.get_observer().messages(); REQUIRE(required == actual); } THEN("result3 contains expected messages"){ - record items[] = { - on_error(900, ex) - }; - auto required = rxu::to_vector(items); + auto required = rxu::to_vector({ + on.on_error(900, ex) + }); auto actual = results3.get_observer().messages(); REQUIRE(required == actual); } -- GitLab From 61dc7e637140c6d9697099cdf062e4b084167036 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Wed, 25 Jun 2014 17:41:38 +0400 Subject: [PATCH 351/782] Convert tabs to spaces --- Rx/v2/test/operators/buffer.cpp | 6 ++-- Rx/v2/test/operators/combine_latest.cpp | 10 +++---- Rx/v2/test/operators/concat.cpp | 40 ++++++++++++------------- Rx/v2/test/operators/concat_map.cpp | 10 +++---- Rx/v2/test/operators/filter.cpp | 8 ++--- Rx/v2/test/operators/merge.cpp | 32 ++++++++++---------- Rx/v2/test/operators/take.cpp | 12 ++++---- Rx/v2/test/sources/defer.cpp | 2 +- 8 files changed, 60 insertions(+), 60 deletions(-) diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index 2153f8d..c98a6e1 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -20,7 +20,7 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ on.on_next(230, 4), on.on_next(240, 5), on.on_completed(250) - }); + }); WHEN("group each int with the next 2 ints"){ @@ -40,7 +40,7 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ v_on.on_next(250, rxu::to_vector(4, 5)), v_on.on_next(250, rxu::to_vector(5)), v_on.on_completed(250) - }); + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -48,7 +48,7 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ THEN("there was one subscription and one unsubscription to the xs"){ auto required = rxu::to_vector({ on.subscribe(200, 250) - }); + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/combine_latest.cpp b/Rx/v2/test/operators/combine_latest.cpp index fb13953..512db72 100644 --- a/Rx/v2/test/operators/combine_latest.cpp +++ b/Rx/v2/test/operators/combine_latest.cpp @@ -16,7 +16,7 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato on.on_next(215, 2), on.on_next(225, 4), on.on_completed(230) - }); + }); auto o2 = sc.make_hot_observable({ on.on_next(150, 1), @@ -25,7 +25,7 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato on.on_next(235, 6), on.on_next(240, 7), on.on_completed(250) - }); + }); WHEN("each int is combined with the latest from the other source"){ @@ -46,7 +46,7 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato on.on_next(235, 4 + 6), on.on_next(240, 4 + 7), on.on_completed(250) - }); + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -54,7 +54,7 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato THEN("there was one subscription and one unsubscription to the o1"){ auto required = rxu::to_vector({ on.subscribe(200, 230) - }); + }); auto actual = o1.subscriptions(); REQUIRE(required == actual); } @@ -62,7 +62,7 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato THEN("there was one subscription and one unsubscription to the o2"){ auto required = rxu::to_vector({ on.subscribe(200, 250) - }); + }); auto actual = o2.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 59a1813..619894a 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -108,7 +108,7 @@ SCENARIO("concat completes", "[concat][join][operators]"){ on.on_next(210, 105), on.on_next(220, 106), on.on_completed(230) - }); + }); auto ys2 = sc.make_cold_observable({ on.on_next(10, 201), @@ -116,7 +116,7 @@ SCENARIO("concat completes", "[concat][join][operators]"){ on.on_next(30, 203), on.on_next(40, 204), on.on_completed(50) - }); + }); auto ys3 = sc.make_cold_observable({ on.on_next(10, 301), @@ -125,14 +125,14 @@ SCENARIO("concat completes", "[concat][join][operators]"){ on.on_next(40, 304), on.on_next(120, 305), on.on_completed(150) - }); + }); auto xs = sc.make_hot_observable({ o_on.on_next(300, ys1), o_on.on_next(400, ys2), o_on.on_next(500, ys3), o_on.on_completed(600) - }); + }); WHEN("each int is merged"){ @@ -147,23 +147,23 @@ SCENARIO("concat completes", "[concat][join][operators]"){ THEN("the output contains merged ints"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 103), - on.on_next(420, 104), - on.on_next(510, 105), + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 103), + on.on_next(420, 104), + on.on_next(510, 105), on.on_next(520, 106), on.on_next(540, 201), on.on_next(550, 202), on.on_next(560, 203), on.on_next(570, 204), - on.on_next(590, 301), - on.on_next(600, 302), - on.on_next(610, 303), - on.on_next(620, 304), - on.on_next(700, 305), - on.on_completed(730) - }); + on.on_next(590, 301), + on.on_next(600, 302), + on.on_next(610, 303), + on.on_next(620, 304), + on.on_next(700, 305), + on.on_completed(730) + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -171,7 +171,7 @@ SCENARIO("concat completes", "[concat][join][operators]"){ THEN("there was one subscription and one unsubscription to the ints"){ auto required = rxu::to_vector({ on.subscribe(200, 600) - }); + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -179,7 +179,7 @@ SCENARIO("concat completes", "[concat][join][operators]"){ THEN("there was one subscription and one unsubscription to the ys1"){ auto required = rxu::to_vector({ on.subscribe(300, 530) - }); + }); auto actual = ys1.subscriptions(); REQUIRE(required == actual); } @@ -187,7 +187,7 @@ SCENARIO("concat completes", "[concat][join][operators]"){ THEN("there was one subscription and one unsubscription to the ys2"){ auto required = rxu::to_vector({ on.subscribe(530, 580) - }); + }); auto actual = ys2.subscriptions(); REQUIRE(required == actual); } @@ -195,7 +195,7 @@ SCENARIO("concat completes", "[concat][join][operators]"){ THEN("there was one subscription and one unsubscription to the ys3"){ auto required = rxu::to_vector({ on.subscribe(580, 730) - }); + }); auto actual = ys3.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index c05fb18..4f6b675 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -187,7 +187,7 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ i_on.on_next(100, 4), i_on.on_next(200, 2), i_on.on_completed(500) - }); + }); auto ys = sc.make_cold_observable({ s_on.on_next(50, "foo"), @@ -195,7 +195,7 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ s_on.on_next(150, "baz"), s_on.on_next(200, "qux"), s_on.on_completed(250) - }); + }); WHEN("each int is mapped to the strings"){ @@ -223,7 +223,7 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ s_on.on_next(700, "baz"), s_on.on_next(750, "qux"), s_on.on_completed(800) - }); + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -231,7 +231,7 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ THEN("there was one subscription and one unsubscription to the ints"){ auto required = rxu::to_vector({ i_on.subscribe(200, 700) - }); + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -240,7 +240,7 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ auto required = rxu::to_vector({ s_on.subscribe(300, 550), s_on.subscribe(550, 800) - }); + }); auto actual = ys.subscriptions(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index 4d56dfa..529f10a 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -123,7 +123,7 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ on.on_next(560, 10), on.on_next(580, 11), on.on_completed(600) - }); + }); WHEN("filtered to ints that are primes"){ @@ -201,7 +201,7 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ on.on_next(610, 12), on.on_error(620, std::runtime_error("error in unsubscribed stream")), on.on_completed(630) - }); + }); WHEN("filtered to ints that are primes"){ @@ -280,7 +280,7 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ on.on_next(610, 12), on.on_error(620, std::runtime_error("error in unsubscribed stream")), on.on_completed(630) - }); + }); WHEN("filtered to ints that are primes"){ @@ -361,7 +361,7 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") on.on_next(610, 12), on.on_error(620, std::exception()), on.on_completed(630) - }); + }); auto res = w.make_subscriber(); diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index d287fe0..73af651 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -148,22 +148,22 @@ SCENARIO("merge completes", "[merge][join][operators]"){ THEN("the output contains merged ints"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 103), - on.on_next(410, 201), - on.on_next(420, 104), - on.on_next(420, 202), - on.on_next(430, 203), - on.on_next(440, 204), - on.on_next(510, 105), - on.on_next(510, 301), - on.on_next(520, 106), - on.on_next(520, 302), - on.on_next(530, 303), - on.on_next(540, 304), - on.on_next(620, 305), - on.on_completed(650) + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 103), + on.on_next(410, 201), + on.on_next(420, 104), + on.on_next(420, 202), + on.on_next(430, 203), + on.on_next(440, 204), + on.on_next(510, 105), + on.on_next(510, 301), + on.on_next(520, 106), + on.on_next(520, 302), + on.on_next(530, 303), + on.on_next(540, 304), + on.on_next(620, 305), + on.on_completed(650) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index f87b9df..39db55f 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -80,7 +80,7 @@ SCENARIO("take, complete after", "[take][operators]"){ on.on_next(590, 5), on.on_next(630, 10), on.on_completed(690) - }); + }); WHEN("20 values are taken"){ @@ -113,7 +113,7 @@ SCENARIO("take, complete after", "[take][operators]"){ on.on_next(590, 5), on.on_next(630, 10), on.on_completed(690) - }); + }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } @@ -121,7 +121,7 @@ SCENARIO("take, complete after", "[take][operators]"){ THEN("there was 1 subscription/unsubscription to the source"){ auto required = rxu::to_vector({ on.subscribe(200, 690) - }); + }); auto actual = xs.subscriptions(); REQUIRE(required == actual); } @@ -641,7 +641,7 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ on.on_next(150, 1), on.on_next(225, 99), on.on_completed(230) - }); + }); WHEN("one is taken until the other emits a marble"){ @@ -697,13 +697,13 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ on.on_next(230, 4), on.on_next(240, 5), on.on_completed(250) - }); + }); auto r = sc.make_hot_observable({ on.on_next(150, 1), on.on_next(225, 99), on.on_completed(230) - }); + }); WHEN("one is taken until the other emits a marble"){ diff --git a/Rx/v2/test/sources/defer.cpp b/Rx/v2/test/sources/defer.cpp index ea44b4d..bf4779e 100644 --- a/Rx/v2/test/sources/defer.cpp +++ b/Rx/v2/test/sources/defer.cpp @@ -32,7 +32,7 @@ SCENARIO("defer stops on completion", "[defer][operators]"){ xs.reset(sc.make_cold_observable({ on.on_next(100, sc.clock()), on.on_completed(200) - })); + })); return xs.get(); }) // forget type to workaround lambda deduction bug on msvc 2013 -- GitLab From 284476f7d0f174631643c951692b992a22612365 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 26 Jun 2014 23:52:53 -0700 Subject: [PATCH 352/782] fix bug in map --- Rx/v2/src/rxcpp/operators/rx-map.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index eda923a..6719f1c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -27,10 +27,10 @@ struct map } template - struct map_observer : public observer_base + struct map_observer : public observer_base { typedef map_observer this_type; - typedef observer_base base_type; + typedef observer_base base_type; typedef typename base_type::value_type value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; -- GitLab From 9291de7e0f4298deaa58c87edad97ea5ac91533a Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 30 Jun 2014 18:50:04 +0400 Subject: [PATCH 353/782] Implement "repeat" operator --- Rx/v2/src/rxcpp/operators/rx-repeat.hpp | 122 ++++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 21 ++++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + 3 files changed, 144 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-repeat.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp new file mode 100644 index 0000000..91f59b8 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp @@ -0,0 +1,122 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_REPEAT_HPP) +#define RXCPP_OPERATORS_RX_REPEAT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct repeat : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type count_type; + struct values + { + values(source_type s, count_type t) + : source(std::move(s)) + , remaining(std::move(t)) + , repeat_infinitely(t == 0) + { + } + source_type source; + count_type remaining; + bool repeat_infinitely; + }; + values initial; + + repeat(source_type s, count_type t) + : initial(std::move(s), std::move(t)) + { + } + + template + void on_subscribe(const Subscriber& s) const { + + typedef Subscriber output_type; + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(const values& i, const output_type& oarg) + : values(i) + , source_lifetime(composite_subscription::empty()) + , out(oarg) + { + } + composite_subscription source_lifetime; + output_type out; + + void do_subscribe() { + auto state = this->shared_from_this(); + + state->source_lifetime = composite_subscription(); + state->out.add(state->source_lifetime); + + state->source.subscribe( + state->out, + state->source_lifetime, + // on_next + [state](T t) { + state->out.on_next(t); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (state->repeat_infinitely || (--state->remaining > 0)) { + state->do_subscribe(); + } else { + state->out.on_completed(); + } + } + ); + } + }; + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, s)); + + // start the first iteration + state->do_subscribe(); + } +}; + +template +class repeat_factory +{ + typedef typename std::decay::type count_type; + count_type count; +public: + repeat_factory(count_type t) : count(std::move(t)) {} + + template + auto operator()(Observable&& source) + -> observable::type::value_type, repeat::type::value_type, Observable, count_type>> { + return observable::type::value_type, repeat::type::value_type, Observable, count_type>>( + repeat::type::value_type, Observable, count_type>(std::forward(source), count)); + } +}; + +} + +template +auto repeat(T&& t) +-> detail::repeat_factory { + return detail::repeat_factory(std::forward(t)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index b1b59fa..cffd448 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -760,6 +760,27 @@ public: return observable>( rxo::detail::take_until(*this, std::forward(t), std::forward(sf))); } + + /// repeat -> + /// infinitely repeate this observable + /// + /// + auto repeat() const + -> observable> { + return observable>( + rxo::detail::repeat(*this, 0)); + } + + /// repeat -> + /// repeate this observable for given number of times + /// + /// + template + auto repeat(Count t) const + -> observable> { + return observable>( + rxo::detail::repeat(*this, t)); + } }; template diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index fbc2c01..01d7a94 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -54,5 +54,6 @@ namespace rxo=operators; #include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" +#include "operators/rx-repeat.hpp" #endif -- GitLab From 7e7880f65b514d2dc215a0e4ff62861cb923af34 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 30 Jun 2014 18:51:03 +0400 Subject: [PATCH 354/782] Add tests for repeat --- Rx/v2/test/operators/repeat.cpp | 347 ++++++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 348 insertions(+) create mode 100644 Rx/v2/test/operators/repeat.cpp diff --git a/Rx/v2/test/operators/repeat.cpp b/Rx/v2/test/operators/repeat.cpp new file mode 100644 index 0000000..10361ea --- /dev/null +++ b/Rx/v2/test/operators/repeat.cpp @@ -0,0 +1,347 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("repeat, basic test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_cold_observable({ + on.on_next(100, 1), + on.on_next(150, 2), + on.on_next(200, 3), + on.on_completed(250) + }); + + WHEN("infinite repeat is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains 3 sets of ints"){ + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(350, 2), + on.on_next(400, 3), + on.on_next(550, 1), + on.on_next(600, 2), + on.on_next(650, 3), + on.on_next(800, 1), + on.on_next(850, 2), + on.on_next(900, 3) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 4 subscriptions and 4 unsubscriptions to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 450), + on.subscribe(450, 700), + on.subscribe(700, 950), + on.subscribe(950, 1000) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("repeat, infinite observable test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints that never completes."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_cold_observable({ + on.on_next(100, 1), + on.on_next(150, 2), + on.on_next(200, 3) + }); + + WHEN("infinite repeat is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains a set of ints"){ + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(350, 2), + on.on_next(400, 3) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription and 1 unsubscription to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("repeat, error test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints followed by an error."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("repeat on_error from source"); + + auto xs = sc.make_cold_observable({ + on.on_next(100, 1), + on.on_next(150, 2), + on.on_next(200, 3), + on.on_error(250, ex) + }); + + WHEN("infinite repeat is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains a set of ints and an error"){ + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(350, 2), + on.on_next(400, 3), + on.on_error(450, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription and 1 unsubscription to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 450) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("countable repeat, basic test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_cold_observable({ + on.on_next(5, 1), + on.on_next(10, 2), + on.on_next(15, 3), + on.on_completed(20) + }); + + WHEN("repeat of 3 iterations is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains 3 sets of ints"){ + auto required = rxu::to_vector({ + on.on_next(205, 1), + on.on_next(210, 2), + on.on_next(215, 3), + on.on_next(225, 1), + on.on_next(230, 2), + on.on_next(235, 3), + on.on_next(245, 1), + on.on_next(250, 2), + on.on_next(255, 3), + on.on_completed(260) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 3 subscriptions and 3 unsubscriptions to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220), + on.subscribe(220, 240), + on.subscribe(240, 260) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("countable repeat, dispose test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_cold_observable({ + on.on_next(5, 1), + on.on_next(10, 2), + on.on_next(15, 3), + on.on_completed(20) + }); + + WHEN("repeat of 3 iterations is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 231 + ); + + THEN("the output contains less than 2 full sets of ints"){ + auto required = rxu::to_vector({ + on.on_next(205, 1), + on.on_next(210, 2), + on.on_next(215, 3), + on.on_next(225, 1), + on.on_next(230, 2), + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 2 subscriptions and 2 unsubscriptions to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220), + on.subscribe(220, 231) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("countable repeat, infinite observable test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints that never completes."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_cold_observable({ + on.on_next(100, 1), + on.on_next(150, 2), + on.on_next(200, 3) + }); + + WHEN("infinite repeat is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains a set of ints"){ + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(350, 2), + on.on_next(400, 3) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription and 1 unsubscription to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("countable repeat, error test", "[repeat][operators]"){ + GIVEN("cold observable of 3 ints followed by an error."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("repeat on_error from source"); + + auto xs = sc.make_cold_observable({ + on.on_next(100, 1), + on.on_next(150, 2), + on.on_next(200, 3), + on.on_error(250, ex) + }); + + WHEN("infinite repeat is launched"){ + + auto res = w.start( + [&]() { + return xs + .repeat(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains a set of ints and an error"){ + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(350, 2), + on.on_next(400, 3), + on.on_error(450, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription and 1 unsubscription to the ints"){ + auto required = rxu::to_vector({ + on.subscribe(200, 450) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 8778802..e5ebf7f 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -45,6 +45,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/scan.cpp ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/reduce.cpp + ${TEST_DIR}/operators/repeat.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/flat_map.cpp -- GitLab From 10dc69d10c8d52abbb3d2ef872ffb9b97dfdb1dc Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 30 Jun 2014 18:54:06 +0400 Subject: [PATCH 355/782] Sort the list of operators --- Rx/v2/src/rxcpp/rx-operators.hpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 01d7a94..4495c5d 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -34,26 +34,26 @@ namespace rxo=operators; } -#include "operators/rx-lift.hpp" #include "operators/rx-buffer_count.hpp" -#include "operators/rx-subscribe.hpp" -#include "operators/rx-filter.hpp" +#include "operators/rx-combine_latest.hpp" +#include "operators/rx-concat.hpp" +#include "operators/rx-concat_map.hpp" +#include "operators/rx-connect_forever.hpp" #include "operators/rx-distinct_until_changed.hpp" +#include "operators/rx-filter.hpp" +#include "operators/rx-flat_map.hpp" +#include "operators/rx-lift.hpp" #include "operators/rx-map.hpp" #include "operators/rx-merge.hpp" -#include "operators/rx-flat_map.hpp" -#include "operators/rx-concat.hpp" -#include "operators/rx-concat_map.hpp" -#include "operators/rx-combine_latest.hpp" #include "operators/rx-multicast.hpp" #include "operators/rx-publish.hpp" -#include "operators/rx-ref_count.hpp" -#include "operators/rx-connect_forever.hpp" #include "operators/rx-reduce.hpp" +#include "operators/rx-ref_count.hpp" +#include "operators/rx-repeat.hpp" #include "operators/rx-scan.hpp" +#include "operators/rx-subscribe.hpp" #include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" -#include "operators/rx-repeat.hpp" #endif -- GitLab From 93f6bfa604bacf2a645ffe9a7ef569137a754f1e Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Wed, 2 Jul 2014 19:16:41 +0400 Subject: [PATCH 356/782] Add tests for combine_latest --- Rx/v2/test/operators/combine_latest.cpp | 1583 ++++++++++++++++++++++- 1 file changed, 1582 insertions(+), 1 deletion(-) diff --git a/Rx/v2/test/operators/combine_latest.cpp b/Rx/v2/test/operators/combine_latest.cpp index 512db72..2916d20 100644 --- a/Rx/v2/test/operators/combine_latest.cpp +++ b/Rx/v2/test/operators/combine_latest.cpp @@ -32,7 +32,12 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato auto res = w.start( [&]() { return o2 - .combine_latest([](int v2, int v1){return v2 + v1;}, o1) + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); } @@ -69,3 +74,1579 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato } } } + +SCENARIO("combine_latest consecutive", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.on_next(235, 4 + 6), + on.on_next(240, 4 + 7), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest consecutive ends with error left", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_error(230, ex) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only an error"){ + auto required = rxu::to_vector({ + on.on_error(230, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest consecutive ends with error right", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_completed(250) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_error(245, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints followed by an error"){ + auto required = rxu::to_vector({ + on.on_next(235, 4 + 6), + on.on_next(240, 4 + 7), + on.on_error(245, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 245) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 245) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest never N", "[combine_latest][join][operators]"){ + GIVEN("N never completed hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const size_t N = 16; + + std::vector> n; + for (int i = 0; i < N; ++i) { + n.push_back( + sc.make_hot_observable({ + on.on_next(150, 1) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n[0] + .combine_latest( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13], n[14], n[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(n.begin(), n.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ + GIVEN("N empty hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const size_t N = 16; + + std::vector> e; + for (int i = 0; i < N; ++i) { + e.push_back( + sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210 + 10 * i) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e[0] + .combine_latest( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(200 + 10 * N) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + int i = 0; + std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 200 + 10 * ++i) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("combine_latest never/empty", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + e + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest empty/never", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest empty/return", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest return/empty", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + e + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest never/return", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest return/never", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest return/return", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(220, 3), + on.on_completed(240) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o1 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.on_next(220, 2 + 3), + on.on_completed(240) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 240) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest empty/error", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto emp = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(230) + }); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return emp + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the emp"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = emp.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error/empty", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + auto emp = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(230) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + emp + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the emp"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = emp.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest return/error", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_completed(230) + }); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error/return", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + auto ret = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_completed(230) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + ret + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = ret.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error/error", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex1("combine_latest on_error from source 1"); + std::runtime_error ex2("combine_latest on_error from source 2"); + + auto err1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex1) + }); + + auto err2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(230, ex2) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err1 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex1) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest next+error/error", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex1("combine_latest on_error from source 1"); + std::runtime_error ex2("combine_latest on_error from source 2"); + + auto err1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_error(220, ex1) + }); + + auto err2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(230, ex2) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err1 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex1) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error/next+error", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex1("combine_latest on_error from source 1"); + std::runtime_error ex2("combine_latest on_error from source 2"); + + auto err1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(230, ex1) + }); + + auto err2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_error(220, ex2) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err1 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex2) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest never/error", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error/never", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error after completed left", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto ret = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_completed(215) + }); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return ret + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 215) + }); + auto actual = ret.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest error after completed right", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto err = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(220, ex) + }); + + auto ret = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_completed(215) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + ret + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 215) + }); + auto actual = ret.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest selector throws", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(220, 3), + on.on_completed(240) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o1 + .combine_latest( + [&ex](int v2, int v1) -> int { + throw ex; + }, + o2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest selector throws N", "[combine_latest][join][operators]"){ + GIVEN("N hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const int N = 16; + + std::runtime_error ex("combine_latest on_error from source"); + + std::vector> e; + for (int i = 0; i < N; ++i) { + e.push_back( + sc.make_hot_observable({ + on.on_next(210 + 10 * i, 1), + on.on_completed(500) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e[0] + .combine_latest( + [&ex](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15) -> int { + throw ex; + }, + e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error"){ + auto required = rxu::to_vector({ + on.on_error(200 + 10 * N, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 200 + 10 * N) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("combine_latest typical N", "[combine_latest][join][operators]"){ + GIVEN("N hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const int N = 16; + + std::vector> o; + for (int i = 0; i < N; ++i) { + o.push_back( + sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210 + 10 * i, i + 1), + on.on_next(410 + 10 * i, i + N + 1), + on.on_completed(800) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o[0] + .combine_latest( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15) { + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10], o[11], o[12], o[13], o[14], o[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.on_next(200 + 10 * N, N * (N + 1) / 2) + }); + for (int i = 0; i < N; ++i) { + required.push_back(on.on_next(410 + 10 * i, N * (N + 1) / 2 + N + N * i)); + } + required.push_back(on.on_completed(800)); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(o.begin(), o.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 800) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} -- GitLab From 4b3902a5d7efa3d0f22141b23578fe470a36f1c8 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 12:23:45 +0400 Subject: [PATCH 357/782] Implement skip operator --- Rx/v2/src/rxcpp/operators/rx-skip.hpp | 126 ++++++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 11 +++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + 3 files changed, 138 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-skip.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-skip.hpp b/Rx/v2/src/rxcpp/operators/rx-skip.hpp new file mode 100644 index 0000000..f986697 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-skip.hpp @@ -0,0 +1,126 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_SKIP_HPP) +#define RXCPP_OPERATORS_RX_SKIP_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct skip : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type count_type; + struct values + { + values(source_type s, count_type t) + : source(std::move(s)) + , count(std::move(t)) + { + } + source_type source; + count_type count; + }; + values initial; + + skip(source_type s, count_type t) + : initial(std::move(s), std::move(t)) + { + } + + struct mode + { + enum type { + skipping, + triggered, + errored, + stopped + }; + }; + + template + void on_subscribe(const Subscriber& s) const { + + typedef Subscriber output_type; + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(const values& i, const output_type& oarg) + : values(i) + , mode_value(count > 0 ? mode::skipping : mode::triggered) + , out(oarg) + { + } + typename mode::type mode_value; + output_type out; + }; + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, s)); + + composite_subscription source_lifetime; + + s.add(source_lifetime); + + state->source.subscribe( + // split subscription lifetime + source_lifetime, + // on_next + [state](T t) { + if (state->mode_value == mode::skipping) { + if (--state->count == 0) { + state->mode_value = mode::triggered; + } + } else { + state->out.on_next(t); + } + }, + // on_error + [state](std::exception_ptr e) { + state->mode_value = mode::errored; + state->out.on_error(e); + }, + // on_completed + [state]() { + state->mode_value = mode::stopped; + state->out.on_completed(); + } + ); + } +}; + +template +class skip_factory +{ + typedef typename std::decay::type count_type; + count_type count; +public: + skip_factory(count_type t) : count(std::move(t)) {} + template + auto operator()(Observable&& source) + -> observable::type::value_type, skip::type::value_type, Observable, count_type>> { + return observable::type::value_type, skip::type::value_type, Observable, count_type>>( + skip::type::value_type, Observable, count_type>(std::forward(source), count)); + } +}; + +} + +template +auto skip(T&& t) + -> detail::skip_factory { + return detail::skip_factory(std::forward(t)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index cffd448..a844c8a 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -724,6 +724,17 @@ public: rxo::detail::scan(*this, std::forward(a), seed)); } + /// skip -> + /// make new observable with skipped first count items from this observable + /// + /// + template + auto skip(Count t) const + -> observable> { + return observable>( + rxo::detail::skip(*this, t)); + } + /// take -> /// for the first count items from this observable emit them from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 4495c5d..251fcb6 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -51,6 +51,7 @@ namespace rxo=operators; #include "operators/rx-ref_count.hpp" #include "operators/rx-repeat.hpp" #include "operators/rx-scan.hpp" +#include "operators/rx-skip.hpp" #include "operators/rx-subscribe.hpp" #include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" -- GitLab From f85433824dde257748bc2f47b4c16b7b4faba41a Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 12:24:24 +0400 Subject: [PATCH 358/782] Add tests for skip operator --- Rx/v2/test/operators/skip.cpp | 637 ++++++++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 638 insertions(+) create mode 100644 Rx/v2/test/operators/skip.cpp diff --git a/Rx/v2/test/operators/skip.cpp b/Rx/v2/test/operators/skip.cpp new file mode 100644 index 0000000..72ede48 --- /dev/null +++ b/Rx/v2/test/operators/skip.cpp @@ -0,0 +1,637 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("skip, complete after", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); + + WHEN("more values than generated are skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(20) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(690) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, complete same", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); + + WHEN("exact number of values is skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(17) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(690) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, complete before", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); + + WHEN("part of values is skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(10) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, complete zero", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); + + WHEN("no values are skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(0) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_completed(690) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, error after", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, ex) + }); + + WHEN("more values than generated are skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(20) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(690, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, error same", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, ex) + }); + + WHEN("exact number of values is skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(17) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains only error message"){ + auto required = rxu::to_vector({ + on.on_error(690, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, error before", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, ex) + }); + + WHEN("part of values is skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10), + on.on_error(690, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 690) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, dispose before", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10) + }); + + WHEN("all generated values are skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 250 + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, dispose after", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_next(410, 15), + on.on_next(415, 16), + on.on_next(460, 72), + on.on_next(510, 76), + on.on_next(560, 32), + on.on_next(570, -100), + on.on_next(580, -3), + on.on_next(590, 5), + on.on_next(630, 10) + }); + + WHEN("some generated values are skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 400 + ); + + THEN("the output contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip, consecutive", "[skip][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(70, 6), + on.on_next(150, 4), + on.on_next(210, 9), + on.on_next(230, 13), + on.on_next(270, 7), + on.on_next(280, 1), + on.on_next(300, -1), + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_completed(400) + }); + + WHEN("3+2 values are skipped"){ + + auto res = w.start( + [xs]() { + return xs + .skip(3) + .skip(2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(310, 3), + on.on_next(340, 8), + on.on_next(370, 11), + on.on_completed(400) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index e5ebf7f..de1bec2 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -46,6 +46,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/repeat.cpp + ${TEST_DIR}/operators/skip.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/flat_map.cpp -- GitLab From 9a8997b00f114d7a8ed79bd1796599e083a83992 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 12:25:50 +0400 Subject: [PATCH 359/782] Sort the list of operator test files --- projects/CMake/CMakeLists.txt | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index de1bec2..332b3e9 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -38,20 +38,20 @@ set(TEST_SOURCES ${TEST_DIR}/operators/buffer.cpp ${TEST_DIR}/operators/combine_latest.cpp ${TEST_DIR}/operators/concat.cpp - ${TEST_DIR}/operators/merge.cpp - ${TEST_DIR}/operators/lift.cpp - ${TEST_DIR}/operators/filter.cpp + ${TEST_DIR}/operators/concat_map.cpp ${TEST_DIR}/operators/distinct_until_changed.cpp - ${TEST_DIR}/operators/scan.cpp - ${TEST_DIR}/operators/switch_on_next.cpp + ${TEST_DIR}/operators/filter.cpp + ${TEST_DIR}/operators/flat_map.cpp + ${TEST_DIR}/operators/lift.cpp + ${TEST_DIR}/operators/map.cpp + ${TEST_DIR}/operators/merge.cpp + ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/repeat.cpp + ${TEST_DIR}/operators/scan.cpp ${TEST_DIR}/operators/skip.cpp + ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/take.cpp - ${TEST_DIR}/operators/publish.cpp - ${TEST_DIR}/operators/flat_map.cpp - ${TEST_DIR}/operators/concat_map.cpp - ${TEST_DIR}/operators/map.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) -- GitLab From 311ad4fc0e8600b9461fc5589651d71079661cd6 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 14:46:19 +0400 Subject: [PATCH 360/782] Move tests for take_until to separate file --- Rx/v2/test/operators/take.cpp | 743 --------------------------- Rx/v2/test/operators/take_until.cpp | 747 ++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 3 files changed, 748 insertions(+), 743 deletions(-) create mode 100644 Rx/v2/test/operators/take_until.cpp diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index 39db55f..34d2a4c 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -619,746 +619,3 @@ SCENARIO("take, dispose after", "[take][operators]"){ } } } - - - -SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - - auto ys = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 99), - on.on_completed(230) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [xs, ys]() { - return xs - .take_until(ys) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_completed(225) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = xs.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = ys.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 99), - on.on_completed(230) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_completed(225) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, preempt some data error", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - std::runtime_error ex("take_until on_error from source"); - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_error(225, ex) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(225) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 250) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 250) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 250) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 2), //! - on.on_completed(250) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_completed(225) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - std::runtime_error ex("take_until on_error from source"); - - auto l = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_error(225, ex) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(225) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, preempt before first produced", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(230, 2), - on.on_completed(240) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), //! - on.on_completed(220) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_completed(210) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 210) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 210) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, preempt before first produced, remain silent and proper unsubscribed", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - bool sourceNotDisposed = false; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(215, std::runtime_error("error in unsubscribed stream")), // should not come - on.on_completed(240) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), //! - on.on_completed(220) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r, &sourceNotDisposed]() { - return l - .map([&sourceNotDisposed](int v){sourceNotDisposed = true; return v;}) - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_completed(210) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("signal disposed"){ - auto required = false; - auto actual = sourceNotDisposed; - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - bool signalNotDisposed = false; - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(230, 2), - on.on_completed(240) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(250, 2), - on.on_completed(260) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r, &signalNotDisposed]() { - return l - .take_until(r - .map([&signalNotDisposed](int v){signalNotDisposed = true; return v;})) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_next(230, 2), - on.on_completed(240) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("signal disposed"){ - auto required = false; - auto actual = signalNotDisposed; - REQUIRE(required == actual); - } - - } - } -} - -SCENARIO("take_until, error some", "[take_until][take][operators]"){ - GIVEN("2 sources"){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - std::runtime_error ex("take_until on_error from source"); - - auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) - }); - - auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(240, 2) - }); - - WHEN("one is taken until the other emits a marble"){ - - auto res = w.start( - [l, r]() { - return l - .take_until(r) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output only contains items sent while subscribed"){ - auto required = rxu::to_vector({ - on.on_error(225, ex) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the source"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = l.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was 1 subscription/unsubscription to the trigger"){ - auto required = rxu::to_vector({ - on.subscribe(200, 225) - }); - auto actual = r.subscriptions(); - REQUIRE(required == actual); - } - - } - } -} diff --git a/Rx/v2/test/operators/take_until.cpp b/Rx/v2/test/operators/take_until.cpp new file mode 100644 index 0000000..432b7e3 --- /dev/null +++ b/Rx/v2/test/operators/take_until.cpp @@ -0,0 +1,747 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto ys = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 99), + on.on_completed(230) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [xs, ys]() { + return xs + .take_until(ys) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_completed(225) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 99), + on.on_completed(230) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_completed(225) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt some data error", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("take_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_error(225, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(225) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 2), //! + on.on_completed(250) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_completed(225) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("take_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_error(225, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(225) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000 /* can't dispose prematurely, could be in flight to dispatch OnError */) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt before first produced", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(230, 2), + on.on_completed(240) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), //! + on.on_completed(220) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_completed(210) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, preempt before first produced, remain silent and proper unsubscribed", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + bool sourceNotDisposed = false; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(215, std::runtime_error("error in unsubscribed stream")), // should not come + on.on_completed(240) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), //! + on.on_completed(220) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r, &sourceNotDisposed]() { + return l + .map([&sourceNotDisposed](int v){sourceNotDisposed = true; return v; }) + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_completed(210) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("signal disposed"){ + auto required = false; + auto actual = sourceNotDisposed; + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + bool signalNotDisposed = false; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(230, 2), + on.on_completed(240) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(250, 2), + on.on_completed(260) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r, &signalNotDisposed]() { + return l + .take_until(r + .map([&signalNotDisposed](int v){signalNotDisposed = true; return v; })) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(230, 2), + on.on_completed(240) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("signal disposed"){ + auto required = false; + auto actual = signalNotDisposed; + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take_until, error some", "[take_until][take][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("take_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(240, 2) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [l, r]() { + return l + .take_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_error(225, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 332b3e9..684fcb1 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -52,6 +52,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/skip.cpp ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/take.cpp + ${TEST_DIR}/operators/take_until.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) -- GitLab From d501bc73bd873a0ae264974c1f4c750872d8b7f4 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 17:23:52 +0400 Subject: [PATCH 361/782] Implement skip_until operator --- Rx/v2/src/rxcpp/operators/rx-skip_until.hpp | 198 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 28 ++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + 3 files changed, 226 insertions(+), 1 deletion(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-skip_until.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp new file mode 100644 index 0000000..49441e4 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp @@ -0,0 +1,198 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_SKIP_UNTIL_HPP) +#define RXCPP_OPERATORS_RX_SKIP_UNTIL_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct skip_until : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type trigger_source_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + struct values + { + values(source_type s, trigger_source_type t, coordination_type sf) + : source(std::move(s)) + , trigger(std::move(t)) + , coordination(std::move(sf)) + { + } + source_type source; + trigger_source_type trigger; + coordination_type coordination; + }; + values initial; + + skip_until(source_type s, trigger_source_type t, coordination_type sf) + : initial(std::move(s), std::move(t), std::move(sf)) + { + } + + struct mode + { + enum type { + skipping, // no messages from trigger + clear, // trigger completed + triggered, // trigger sent on_next + errored, // error either on trigger or on observable + stopped // observable completed + }; + }; + + template + void on_subscribe(Subscriber s) const { + + typedef Subscriber output_type; + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(const values& i, coordinator_type coor, const output_type& oarg) + : values(i) + , mode_value(mode::skipping) + , coordinator(std::move(coor)) + , out(oarg) + { + out.add(trigger_lifetime); + out.add(source_lifetime); + } + typename mode::type mode_value; + composite_subscription trigger_lifetime; + composite_subscription source_lifetime; + coordinator_type coordinator; + output_type out; + }; + + auto coordinator = initial.coordination.create_coordinator(); + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(s))); + + auto trigger = on_exception( + [&](){return state->coordinator.in(state->trigger);}, + state->out); + if (trigger.empty()) { + return; + } + + auto source = on_exception( + [&](){return state->coordinator.in(state->source);}, + state->out); + if (source.empty()) { + return; + } + + auto sinkTrigger = make_subscriber( + // share parts of subscription + state->out, + // new lifetime + state->trigger_lifetime, + // on_next + [state](const typename trigger_source_type::value_type&) { + if (state->mode_value != mode::skipping) { + return; + } + state->mode_value = mode::triggered; + state->trigger_lifetime.unsubscribe(); + }, + // on_error + [state](std::exception_ptr e) { + if (state->mode_value != mode::skipping) { + return; + } + state->mode_value = mode::errored; + state->out.on_error(e); + }, + // on_completed + [state]() { + if (state->mode_value != mode::skipping) { + return; + } + state->mode_value = mode::clear; + state->trigger_lifetime.unsubscribe(); + } + ); + auto selectedSinkTrigger = on_exception( + [&](){return state->coordinator.out(sinkTrigger);}, + state->out); + if (selectedSinkTrigger.empty()) { + return; + } + trigger->subscribe(std::move(selectedSinkTrigger.get())); + + source.get().subscribe( + // split subscription lifetime + state->source_lifetime, + // on_next + [state](T t) { + if (state->mode_value != mode::triggered) { + return; + } + state->out.on_next(t); + }, + // on_error + [state](std::exception_ptr e) { + if (state->mode_value > mode::triggered) { + return; + } + state->mode_value = mode::errored; + state->out.on_error(e); + }, + // on_completed + [state]() { + if (state->mode_value != mode::triggered) { + return; + } + state->mode_value = mode::stopped; + state->out.on_completed(); + } + ); + } +}; + +template +class skip_until_factory +{ + typedef typename std::decay::type trigger_source_type; + typedef typename std::decay::type coordination_type; + + trigger_source_type trigger_source; + coordination_type coordination; +public: + skip_until_factory(trigger_source_type t, coordination_type sf) + : trigger_source(std::move(t)) + , coordination(std::move(sf)) + { + } + template + auto operator()(Observable&& source) + -> observable::type::value_type, skip_until::type::value_type, Observable, trigger_source_type, Coordination>> { + return observable::type::value_type, skip_until::type::value_type, Observable, trigger_source_type, Coordination>>( + skip_until::type::value_type, Observable, trigger_source_type, Coordination>(std::forward(source), trigger_source, coordination)); + } +}; + +} + +template +auto skip_until(TriggerObservable&& t, Coordination&& sf) + -> detail::skip_until_factory { + return detail::skip_until_factory(std::forward(t), std::forward(sf)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a844c8a..e0e90c2 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -735,6 +735,32 @@ public: rxo::detail::skip(*this, t)); } + /// skip_until -> + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// make new observable with items skipped until on_next occurs on the TriggerSource + /// + /// + template + auto skip_until(TriggerSource&& t) const + -> typename std::enable_if::value, + observable>>::type { + return observable>( + rxo::detail::skip_until(*this, std::forward(t), identity_one_worker(rxsc::make_current_thread()))); + } + + /// skip_until -> + /// The coordination is used to synchronize sources from different contexts. + /// make new observable with items skipped until on_next occurs on the TriggerSource + /// + /// + template + auto skip_until(TriggerSource&& t, Coordination&& sf) const + -> typename std::enable_if::value && is_coordination::value, + observable>>::type { + return observable>( + rxo::detail::skip_until(*this, std::forward(t), std::forward(sf))); + } + /// take -> /// for the first count items from this observable emit them from the new observable that is returned. /// @@ -773,7 +799,7 @@ public: } /// repeat -> - /// infinitely repeate this observable + /// infinitely repeat this observable /// /// auto repeat() const diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 251fcb6..cd9410f 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -52,6 +52,7 @@ namespace rxo=operators; #include "operators/rx-repeat.hpp" #include "operators/rx-scan.hpp" #include "operators/rx-skip.hpp" +#include "operators/rx-skip_until.hpp" #include "operators/rx-subscribe.hpp" #include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" -- GitLab From efad96449bcedd34babe6e4b3fe42dd518c6a5cf Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 17:24:20 +0400 Subject: [PATCH 362/782] Add tests for skip_until operator --- Rx/v2/test/operators/skip_until.cpp | 564 ++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 565 insertions(+) create mode 100644 Rx/v2/test/operators/skip_until.cpp diff --git a/Rx/v2/test/operators/skip_until.cpp b/Rx/v2/test/operators/skip_until.cpp new file mode 100644 index 0000000..51db1ba --- /dev/null +++ b/Rx/v2/test/operators/skip_until.cpp @@ -0,0 +1,564 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("skip_until, some data next", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 99), + on.on_completed(230) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, some data error", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains error message"){ + auto required = rxu::to_vector({ + on.on_error(225, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, error some data", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_error(220, ex) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(230, 3), + on.on_completed(250) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains error message"){ + auto required = rxu::to_vector({ + on.on_error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, some data empty", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(225) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, never next", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(225, 2), + on.on_completed(250) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, never error", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(225, ex) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains error message"){ + auto required = rxu::to_vector({ + on.on_error(225, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, some data error after completed", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("skip_until on_error from source"); + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(300, ex) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains error message"){ + auto required = rxu::to_vector({ + on.on_error(300, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 300) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, some data never", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, never empty", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(225) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("skip_until, never never", "[skip_until][skip][operators]"){ + GIVEN("2 sources"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto l = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto r = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("one is taken until the other emits a marble"){ + + auto res = w.start( + [&]() { + return l + .skip_until(r) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = l.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the trigger"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = r.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 684fcb1..de7e3f3 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -50,6 +50,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/repeat.cpp ${TEST_DIR}/operators/scan.cpp ${TEST_DIR}/operators/skip.cpp + ${TEST_DIR}/operators/skip_until.cpp ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/take_until.cpp -- GitLab From c4081892d9482b1af18ed322b19344986ef46cf4 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 17:30:18 +0400 Subject: [PATCH 363/782] Fix state transition on take_until and add comments to states to facilitate reading in future --- Rx/v2/src/rxcpp/operators/rx-skip.hpp | 8 ++++---- Rx/v2/src/rxcpp/operators/rx-take.hpp | 8 ++++---- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 12 ++++++------ 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-skip.hpp b/Rx/v2/src/rxcpp/operators/rx-skip.hpp index f986697..9a36969 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip.hpp @@ -38,10 +38,10 @@ struct skip : public operator_base struct mode { enum type { - skipping, - triggered, - errored, - stopped + skipping, // ignore messages + triggered, // capture messages + errored, // error occured + stopped // observable completed }; }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index 46bca55..5043385 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -38,10 +38,10 @@ struct take : public operator_base struct mode { enum type { - taking, - triggered, - errored, - stopped + taking, // capture messages + triggered, // ignore messages + errored, // error occured + stopped // observable completed }; }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 00dc952..510a4ae 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -42,11 +42,11 @@ struct take_until : public operator_base struct mode { enum type { - taking, - clear, - triggered, - errored, - stopped + taking, // no messages from trigger + clear, // trigger completed + triggered, // trigger sent on_next + errored, // error either on trigger or on observable + stopped // observable completed }; }; @@ -145,7 +145,7 @@ struct take_until : public operator_base // on_completed [state]() { if (state->mode_value > mode::clear) {return;} - state->mode_value = mode::triggered; + state->mode_value = mode::stopped; state->out.on_completed(); } ); -- GitLab From c0e03e4b40e4dbec6c5fb8d64db20a3411ab9fee Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 3 Jul 2014 18:11:51 +0400 Subject: [PATCH 364/782] Repair GCC compilation --- Rx/v2/src/rxcpp/operators/rx-skip.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-skip.hpp b/Rx/v2/src/rxcpp/operators/rx-skip.hpp index 9a36969..3fa7209 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip.hpp @@ -55,7 +55,7 @@ struct skip : public operator_base { state_type(const values& i, const output_type& oarg) : values(i) - , mode_value(count > 0 ? mode::skipping : mode::triggered) + , mode_value(i.count > 0 ? mode::skipping : mode::triggered) , out(oarg) { } -- GitLab From ffadb4fca617d10f36d2d3c1821527c00d66b07b Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 7 Jul 2014 18:10:50 +0400 Subject: [PATCH 365/782] Add tests for operators buffer, distinct_until_changed, scan, switch_on_next --- Rx/v2/test/operators/buffer.cpp | 407 +++++++++++++++++- .../test/operators/distinct_until_changed.cpp | 251 ++++++++++- Rx/v2/test/operators/scan.cpp | 239 +++++++++- Rx/v2/test/operators/switch_on_next.cpp | 283 +++++++++++- 4 files changed, 1172 insertions(+), 8 deletions(-) diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index c98a6e1..f02d8fe 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -6,6 +6,197 @@ namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" +SCENARIO("buffer count partial window", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + WHEN("group each int with the next 4 ints"){ + + auto res = w.start( + [&]() { + return xs + .buffer(5) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(250, rxu::to_vector({ 2, 3, 4, 5 })), + v_on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer count full windows", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + WHEN("group each int with the next int"){ + + auto res = w.start( + [&]() { + return xs + .buffer(2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(220, rxu::to_vector({ 2, 3 })), + v_on.on_next(240, rxu::to_vector({ 4, 5 })), + v_on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer count full and partial windows", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + WHEN("group each int with the next 2 ints"){ + + auto res = w.start( + [&]() { + return xs + .buffer(3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(230, rxu::to_vector({ 2, 3, 4 })), + v_on.on_next(250, rxu::to_vector({ 5 })), + v_on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer count error", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + std::runtime_error ex("buffer on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_error(250, ex) + }); + + WHEN("group each int with the next 4 ints"){ + + auto res = w.start( + [&]() { + return xs + .buffer(5) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_error(250, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + SCENARIO("buffer count skip less", "[buffer][operators]"){ GIVEN("1 hot observable of ints."){ auto sc = rxsc::make_test(); @@ -35,10 +226,58 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(230, rxu::to_vector(2, 3, 4)), - v_on.on_next(240, rxu::to_vector(3, 4, 5)), - v_on.on_next(250, rxu::to_vector(4, 5)), - v_on.on_next(250, rxu::to_vector(5)), + v_on.on_next(230, rxu::to_vector({ 2, 3, 4 })), + v_on.on_next(240, rxu::to_vector({ 3, 4, 5 })), + v_on.on_next(250, rxu::to_vector({ 4, 5 })), + v_on.on_next(250, rxu::to_vector({ 5 })), + v_on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer count skip more", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + WHEN("group each int with the next int skipping the third one"){ + + auto res = w.start( + [&]() { + return xs + .buffer(2, 3) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(220, rxu::to_vector({ 2, 3 })), + v_on.on_next(250, rxu::to_vector({ 5 })), v_on.on_completed(250) }); auto actual = res.get_observer().messages(); @@ -52,7 +291,167 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ auto actual = xs.subscriptions(); REQUIRE(required == actual); } + } + } +} + +SCENARIO("buffer count basic", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + + auto res = w.start( + [&]() { + return xs + .buffer(3, 2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(280, rxu::to_vector({ 2, 3, 4 })), + v_on.on_next(350, rxu::to_vector({ 4, 5, 6 })), + v_on.on_next(420, rxu::to_vector({ 6, 7, 8 })), + v_on.on_next(600, rxu::to_vector({ 8, 9 })), + v_on.on_completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer count disposed", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + + auto res = w.start( + [&]() { + return xs + .buffer(3, 2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 370 + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(280, rxu::to_vector({ 2, 3, 4 })), + v_on.on_next(350, rxu::to_vector({ 4, 5, 6 })), + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 370) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer count error 2", "[buffer][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + std::runtime_error ex("buffer on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_error(600, ex) + }); + + WHEN("group each int with the next 2 ints"){ + + auto res = w.start( + [&]() { + return xs + .buffer(3, 2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.on_next(280, rxu::to_vector({ 2, 3, 4 })), + v_on.on_next(350, rxu::to_vector({ 4, 5, 6 })), + v_on.on_next(420, rxu::to_vector({ 6, 7, 8 })), + v_on.on_error(600, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } } } } diff --git a/Rx/v2/test/operators/distinct_until_changed.cpp b/Rx/v2/test/operators/distinct_until_changed.cpp index 7df96ee..150b086 100644 --- a/Rx/v2/test/operators/distinct_until_changed.cpp +++ b/Rx/v2/test/operators/distinct_until_changed.cpp @@ -1,10 +1,257 @@ #include "rxcpp/rx.hpp" -namespace rxu=rxcpp::util; -namespace rxsc=rxcpp::schedulers; +namespace rxu = rxcpp::util; +namespace rxsc = rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" +SCENARIO("distinct_until_changed - never", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("distinct_until_changed - empty", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(250) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output only contains complete message"){ + auto required = rxu::to_vector({ + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("distinct_until_changed - return", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_completed(250) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("distinct_until_changed - throw", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("distinct_until_changed on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(250, ex) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output only contains only error"){ + auto required = rxu::to_vector({ + on.on_error(250, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("distinct_until_changed - all changes", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("distinct_until_changed - all same", "[distinct_until_changed][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 2), + on.on_next(230, 2), + on.on_next(240, 2), + on.on_completed(250) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.distinct_until_changed(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + SCENARIO("distinct_until_changed - some changes", "[distinct_until_changed][operators]"){ GIVEN("a source"){ auto sc = rxsc::make_test(); diff --git a/Rx/v2/test/operators/scan.cpp b/Rx/v2/test/operators/scan.cpp index 3615ff2..58ec27e 100644 --- a/Rx/v2/test/operators/scan.cpp +++ b/Rx/v2/test/operators/scan.cpp @@ -5,7 +5,188 @@ namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" -SCENARIO("scan some data with seed", "[scan][operators]"){ +SCENARIO("scan: seed, never", "[scan][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int seed = 1; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + }); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .scan(seed, [](int sum, int x) { + return sum + x; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scan: seed, empty", "[scan][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int seed = 1; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(250) + }); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .scan(seed, [](int sum, int x) { + return sum + x; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scan: seed, return", "[scan][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int seed = 1; + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(220, 2), + on.on_completed(250) + }); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .scan(seed, [](int sum, int x) { + return sum + x; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_next(220, seed + 2), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scan: seed, throw", "[scan][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int seed = 1; + + std::runtime_error ex("scan on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_error(250, ex) + }); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .scan(seed, [](int sum, int x) { + return sum + x; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on error"){ + auto required = rxu::to_vector({ + on.on_error(250, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scan: seed, some data", "[scan][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -57,3 +238,59 @@ SCENARIO("scan some data with seed", "[scan][operators]"){ } } } + +SCENARIO("scan: seed, accumulator throws", "[scan][operators]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int seed = 1; + + std::runtime_error ex("scan on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(210, 2), + on.on_next(220, 3), + on.on_next(230, 4), + on.on_next(240, 5), + on.on_completed(250) + }); + + WHEN("mapped to ints that are one larger"){ + + auto res = w.start( + [&]() { + return xs + .scan(seed, [&](int sum, int x) { + if (x == 4) { + throw ex; + } + return sum + x; + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on error"){ + auto required = rxu::to_vector({ + on.on_next(210, seed + 2), + on.on_next(220, seed + 2 + 3), + on.on_error(230, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/Rx/v2/test/operators/switch_on_next.cpp b/Rx/v2/test/operators/switch_on_next.cpp index 7831d48..9a06b68 100644 --- a/Rx/v2/test/operators/switch_on_next.cpp +++ b/Rx/v2/test/operators/switch_on_next.cpp @@ -2,6 +2,7 @@ namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxsc=rxcpp::schedulers; +namespace rxn=rx::notifications; #include "rxcpp/rx-test.hpp" #include "catch.hpp" @@ -74,7 +75,7 @@ SCENARIO("switch_on_next - some changes", "[switch_on_next][operators]"){ THEN("there was 1 subscription/unsubscription to the source"){ auto required = rxu::to_vector({ - on.subscribe(200, 600) + o_on.subscribe(200, 600) }); auto actual = xs.subscriptions(); REQUIRE(required == actual); @@ -106,3 +107,283 @@ SCENARIO("switch_on_next - some changes", "[switch_on_next][operators]"){ } } } + +SCENARIO("switch_on_next - inner throws", "[switch_on_next][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + std::runtime_error ex("switch_on_next on_error from source"); + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto ys2 = sc.make_cold_observable({ + on.on_next(10, 201), + on.on_next(20, 202), + on.on_next(30, 203), + on.on_next(40, 204), + on.on_error(50, ex) + }); + + auto ys3 = sc.make_cold_observable({ + on.on_next(10, 301), + on.on_next(20, 302), + on.on_next(30, 303), + on.on_next(40, 304), + on.on_completed(150) + }); + + auto xs = sc.make_hot_observable({ + o_on.on_next(300, ys1), + o_on.on_next(400, ys2), + o_on.on_next(500, ys3), + o_on.on_completed(600) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.switch_on_next(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 201), + on.on_next(420, 202), + on.on_next(430, 203), + on.on_next(440, 204), + on.on_error(450, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 450) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys1"){ + auto required = rxu::to_vector({ + on.subscribe(300, 400) + }); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys2"){ + auto required = rxu::to_vector({ + on.subscribe(400, 450) + }); + auto actual = ys2.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys3"){ + auto required = std::vector(); + auto actual = ys3.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("switch_on_next - outer throws", "[switch_on_next][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + std::runtime_error ex("switch_on_next on_error from source"); + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto ys2 = sc.make_cold_observable({ + on.on_next(10, 201), + on.on_next(20, 202), + on.on_next(30, 203), + on.on_next(40, 204), + on.on_completed(50) + }); + + auto xs = sc.make_hot_observable({ + o_on.on_next(300, ys1), + o_on.on_next(400, ys2), + o_on.on_error(500, ex) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.switch_on_next(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 201), + on.on_next(420, 202), + on.on_next(430, 203), + on.on_next(440, 204), + on.on_error(500, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 500) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys1"){ + auto required = rxu::to_vector({ + on.subscribe(300, 400) + }); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys2"){ + auto required = rxu::to_vector({ + on.subscribe(400, 450) + }); + auto actual = ys2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("switch_on_next - no inner", "[switch_on_next][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + o_on.on_completed(500) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.switch_on_next(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_completed(500) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 500) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("switch_on_next - inner completes", "[switch_on_next][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto ys1 = sc.make_cold_observable({ + on.on_next(10, 101), + on.on_next(20, 102), + on.on_next(110, 103), + on.on_next(120, 104), + on.on_next(210, 105), + on.on_next(220, 106), + on.on_completed(230) + }); + + auto xs = sc.make_hot_observable({ + o_on.on_next(300, ys1), + o_on.on_completed(540) + }); + + WHEN("distinct values are taken"){ + + auto res = w.start( + [xs]() { + return xs.switch_on_next(); + } + ); + + THEN("the output only contains distinct items sent while subscribed"){ + auto required = rxu::to_vector({ + on.on_next(310, 101), + on.on_next(320, 102), + on.on_next(410, 103), + on.on_next(420, 104), + on.on_next(510, 105), + on.on_next(520, 106), + on.on_completed(540) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 540) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to ys1"){ + auto required = rxu::to_vector({ + on.subscribe(300, 530) + }); + auto actual = ys1.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From d5f89a402a76b32665f1bb5cc394dda163a02842 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 30 Jun 2014 15:10:09 -0700 Subject: [PATCH 366/782] add as_dynamic, remove incorrect coordination of subscriber --- Rx/v2/src/rxcpp/rx-observer.hpp | 118 ++++++++++---------- Rx/v2/src/rxcpp/rx-subscriber.hpp | 4 + Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 24 ++-- 3 files changed, 79 insertions(+), 67 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index d9f20a0..2dff1e8 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -131,63 +131,6 @@ public: } }; -template -class observer : public observer_base -{ - typedef observer this_type; - typedef typename std::decay::type inner_t; - - inner_t inner; - - observer(); -public: - ~observer() - { - } - observer(const this_type& o) - : inner(o.inner) - { - } - observer(this_type&& o) - : inner(std::move(o.inner)) - { - } - explicit observer(inner_t inner) - : inner(std::move(inner)) - { - } - this_type& operator=(this_type o) { - inner = std::move(o.inner); - return *this; - } - template - void on_next(V&& v) const { - inner.on_next(std::forward(v)); - } - void on_error(std::exception_ptr e) const { - inner.on_error(e); - } - void on_completed() const { - inner.on_completed(); - } -}; -template -class observer : public observer_base -{ - typedef observer this_type; -public: - observer() - { - } - template - void on_next(V&&) const { - } - void on_error(std::exception_ptr) const { - } - void on_completed() const { - } -}; - template class dynamic_observer { @@ -276,6 +219,67 @@ public: } }; + +template +class observer : public observer_base +{ + typedef observer this_type; + typedef typename std::decay::type inner_t; + + inner_t inner; + + observer(); +public: + ~observer() + { + } + observer(const this_type& o) + : inner(o.inner) + { + } + observer(this_type&& o) + : inner(std::move(o.inner)) + { + } + explicit observer(inner_t inner) + : inner(std::move(inner)) + { + } + this_type& operator=(this_type o) { + inner = std::move(o.inner); + return *this; + } + template + void on_next(V&& v) const { + inner.on_next(std::forward(v)); + } + void on_error(std::exception_ptr e) const { + inner.on_error(e); + } + void on_completed() const { + inner.on_completed(); + } + observer as_dynamic() const { + return observer(dynamic_observer(inner)); + } +}; +template +class observer : public observer_base +{ + typedef observer this_type; +public: + observer() + { + } + template + void on_next(V&&) const { + } + void on_error(std::exception_ptr) const { + } + void on_completed() const { + } +}; + template auto make_observer() -> observer { diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index cea6337..90cc7d4 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -80,6 +80,10 @@ public: return lifetime; } + subscriber as_dynamic() const { + return subscriber(lifetime, destination.as_dynamic()); + } + // observer // template diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 46408f8..a128016 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -55,8 +55,8 @@ class synchronize_observer : public detail::multicast_observer if (current == mode::Empty) { current = mode::Processing; auto keepAlive = this->shared_from_this(); - auto processor = coordinator.get_worker(); - processor.schedule(lifetime, [keepAlive, this](const rxsc::schedulable& self){ + + auto drain_queue = [keepAlive, this](const rxsc::schedulable& self){ try { std::unique_lock guard(lock); if (!destination.is_subscribed()) { @@ -80,7 +80,17 @@ class synchronize_observer : public detail::multicast_observer std::unique_lock guard(lock); current = mode::Empty; } - }); + }; + + auto selectedDrain = on_exception( + [&](){return coordinator.act(drain_queue);}, + destination); + if (selectedDrain.empty()) { + return; + } + + auto processor = coordinator.get_worker(); + processor.schedule(lifetime, selectedDrain.get()); } } @@ -129,14 +139,8 @@ public: // creates a worker whose lifetime is the same as the destination subscription auto coordinator = cn.create_coordinator(dl); - auto selectedDest = on_exception( - [&](){return coordinator.out(o);}, - o); - if (selectedDest.empty()) { - return; - } - state = std::make_shared(std::move(coordinator), std::move(il), std::move(selectedDest.get())); + state = std::make_shared(std::move(coordinator), std::move(il), std::move(o)); } template -- GitLab From ad7e64d00025351d9784905216ca6c8386e5800b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 1 Jul 2014 08:33:37 -0700 Subject: [PATCH 367/782] more work on coordination --- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 13 +++- Rx/v2/src/rxcpp/rx-coordination.hpp | 47 ++++++++++++-- Rx/v2/src/rxcpp/rx-observable.hpp | 68 +++++++++++++++------ Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 6 +- Rx/v2/src/rxcpp/sources/rx-error.hpp | 32 ++++++---- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 43 +++++++++---- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 63 ++++++++++--------- Rx/v2/src/rxcpp/sources/rx-range.hpp | 16 +++-- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 23 ++++++- Rx/v2/test/operators/take.cpp | 2 + 10 files changed, 225 insertions(+), 88 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 510a4ae..2f25e74 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -124,7 +124,7 @@ struct take_until : public operator_base } trigger->subscribe(std::move(selectedSinkTrigger.get())); - source.get().subscribe( + auto sinkSource = make_subscriber( // split subscription lifetime state->source_lifetime, // on_next @@ -149,6 +149,13 @@ struct take_until : public operator_base state->out.on_completed(); } ); + auto selectedSinkSource = on_exception( + [&](){return state->coordinator.out(sinkSource);}, + state->out); + if (selectedSinkSource.empty()) { + return; + } + source->subscribe(std::move(selectedSinkSource.get())); } }; @@ -177,9 +184,9 @@ public: } template -auto take_until(TriggerObservable&& t, Coordination&& sf) +auto take_until(TriggerObservable t, Coordination sf) -> detail::take_until_factory { - return detail::take_until_factory(std::forward(t), std::forward(sf)); + return detail::take_until_factory(std::move(t), std::move(sf)); } } diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index 39cd134..1a3c6f3 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -119,12 +119,15 @@ class identity_one_worker : public coordination_base , factory(rxsc::make_same_worker(w)) { } - rxsc::worker get_worker() const { + inline rxsc::worker get_worker() const { return controller; } - rxsc::scheduler get_scheduler() const { + inline rxsc::scheduler get_scheduler() const { return factory; } + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } template auto in(Observable o) const -> Observable { @@ -148,12 +151,26 @@ public: typedef coordinator coordinator_type; - coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } + + inline coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { auto w = factory.create_worker(std::move(cs)); return coordinator_type(input_type(std::move(w))); } }; +inline identity_one_worker identity_immediate() { + static identity_one_worker r(rxsc::make_immediate()); + return r; +} + +inline identity_one_worker identity_current_thread() { + static identity_one_worker r(rxsc::make_current_thread()); + return r; +} + class serialize_one_worker : public coordination_base { rxsc::scheduler factory; @@ -227,12 +244,15 @@ class serialize_one_worker : public coordination_base , lock(std::move(m)) { } - rxsc::worker get_worker() const { + inline rxsc::worker get_worker() const { return controller; } - rxsc::scheduler get_scheduler() const { + inline rxsc::scheduler get_scheduler() const { return factory; } + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } template auto in(Observable o) const -> Observable { @@ -256,13 +276,28 @@ public: typedef coordinator coordinator_type; - coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } + + inline coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { auto w = factory.create_worker(std::move(cs)); std::shared_ptr lock = std::make_shared(); return coordinator_type(input_type(std::move(w), std::move(lock))); } }; +inline serialize_one_worker serialize_event_loop() { + static serialize_one_worker r(rxsc::make_event_loop()); + return r; +} + +inline serialize_one_worker serialize_new_thread() { + static serialize_one_worker r(rxsc::make_new_thread()); + return r; +} + + } #endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index e0e90c2..1d4bc1d 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -371,7 +371,7 @@ public: /// auto switch_on_next() const -> typename switch_on_next_result::type { - return switch_on_next_result::make(this, identity_one_worker(rxsc::make_current_thread())); + return switch_on_next_result::make(this, identity_current_thread()); } /// switch_on_next (AKA Switch) -> @@ -417,7 +417,7 @@ public: /// auto merge() const -> typename merge_result::type { - return merge_result::make(this, identity_one_worker(rxsc::make_current_thread())); + return merge_result::make(this, identity_current_thread()); } /// merge -> @@ -465,7 +465,7 @@ public: auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const -> observable::value_type, rxo::detail::flat_map> { return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_one_worker(rxsc::make_current_thread()))); + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_current_thread())); } /// flat_map (AKA SelectMany) -> @@ -511,7 +511,7 @@ public: /// auto concat() const -> typename concat_result::type { - return concat_result::make(this, identity_one_worker(rxsc::make_current_thread())); + return concat_result::make(this, identity_current_thread()); } /// concat -> @@ -557,7 +557,7 @@ public: auto concat_map(CollectionSelector&& s, ResultSelector&& rs) const -> observable::value_type, rxo::detail::concat_map> { return observable::value_type, rxo::detail::concat_map>( - rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_one_worker(rxsc::make_current_thread()))); + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_current_thread())); } /// concat_map -> @@ -587,7 +587,7 @@ public: -> typename std::enable_if::value && !is_observable::value && rxu::all_true::value...>::value, delayed_combine_latest>::type::type { return observable::value_type, rxo::detail::combine_latest>( - rxo::detail::combine_latest(identity_one_worker(rxsc::make_current_thread()), std::forward(s), std::make_tuple(*this, on...))); + rxo::detail::combine_latest(identity_current_thread(), std::forward(s), std::make_tuple(*this, on...))); } /// combine_latest -> @@ -611,7 +611,7 @@ public: -> typename std::enable_if::value...>::value, delayed_combine_latest>::type::type { return observable::value_type, rxo::detail::combine_latest>( - rxo::detail::combine_latest(identity_one_worker(rxsc::make_current_thread()), rxu::pack(), std::make_tuple(*this, on...))); + rxo::detail::combine_latest(identity_current_thread(), rxu::pack(), std::make_tuple(*this, on...))); } /// combine_latest -> @@ -778,11 +778,11 @@ public: /// /// template - auto take_until(TriggerSource&& t) const + auto take_until(TriggerSource t) const -> typename std::enable_if::value, observable>>::type { return observable>( - rxo::detail::take_until(*this, std::forward(t), identity_one_worker(rxsc::make_current_thread()))); + rxo::detail::take_until(*this, std::move(t), identity_current_thread())); } /// take_until -> @@ -791,15 +791,40 @@ public: /// /// template - auto take_until(TriggerSource&& t, Coordination&& sf) const + auto take_until(TriggerSource t, Coordination sf) const -> typename std::enable_if::value && is_coordination::value, observable>>::type { return observable>( - rxo::detail::take_until(*this, std::forward(t), std::forward(sf))); + rxo::detail::take_until(*this, std::move(t), std::move(sf))); + } + + /// take_until -> + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// for each item from this observable until on_next occurs on the TriggerSource, emit them from the new observable that is returned. + /// + /// + template + auto take_until(TimePoint when) const + -> typename std::enable_if::value, + observable>>::type { + auto cn = identity_current_thread(); + return take_until(rxs::interval(when, cn), cn); + } + + /// take_until -> + /// The coordination is used to synchronize sources from different contexts. + /// for each item from this observable until on_next occurs on the TriggerSource, emit them from the new observable that is returned. + /// + /// + template + auto take_until(rxsc::scheduler::clock_type::time_point when, Coordination cn) const + -> typename std::enable_if::value, + observable>>::type { + return take_until(rxs::interval(when, cn), cn); } /// repeat -> - /// infinitely repeat this observable + /// infinitely repeats this observable /// /// auto repeat() const @@ -809,7 +834,7 @@ public: } /// repeat -> - /// repeate this observable for given number of times + /// repeats this observable for given number of times /// /// template @@ -838,8 +863,8 @@ class observable public: template static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1) - -> decltype(rxs::range(first, last, step, identity_one_worker(rxsc::make_current_thread()))) { - return rxs::range(first, last, step, identity_one_worker(rxsc::make_current_thread())); + -> decltype(rxs::range(first, last, step, identity_current_thread())) { + return rxs::range(first, last, step, identity_current_thread()); } template static auto range(T first, T last, ptrdiff_t step, Coordination cn) @@ -866,6 +891,15 @@ public: -> decltype(rxs::defer(std::move(of))) { return rxs::defer(std::move(of)); } + static auto interval(rxsc::scheduler::clock_type::time_point when) + -> decltype(rxs::interval(when)) { + return rxs::interval(when); + } + template + static auto interval(rxsc::scheduler::clock_type::time_point when, Coordination cn) + -> decltype(rxs::interval(when, std::move(cn))) { + return rxs::interval(when, std::move(cn)); + } static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period) -> decltype(rxs::interval(initial, period)) { return rxs::interval(initial, period); @@ -877,8 +911,8 @@ public: } template static auto iterate(Collection c) - -> decltype(rxs::iterate(std::move(c), identity_one_worker(rxsc::make_current_thread()))) { - return rxs::iterate(std::move(c), identity_one_worker(rxsc::make_current_thread())); + -> decltype(rxs::iterate(std::move(c), identity_current_thread())) { + return rxs::iterate(std::move(c), identity_current_thread()); } template static auto iterate(Collection c, Coordination cn) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 336cf1b..068125a 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -45,12 +45,12 @@ public: virtual clock_type::time_point to_time_point(long absolute) const { - return clock_type::time_point(clock_type::duration(absolute)); + return clock_type::time_point(std::chrono::milliseconds(absolute)); } virtual long to_relative(clock_type::duration d) const { - return static_cast(d.count()); + return static_cast(std::chrono::duration_cast(d).count()); } }; @@ -79,7 +79,7 @@ public: } virtual void schedule(clock_type::time_point when, const schedulable& scbl) const { - state->schedule_absolute(state->to_relative(when - now()), scbl); + state->schedule_relative(state->to_relative(when - now()), scbl); } void schedule_absolute(absolute when, const schedulable& scbl) const { diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index 439f01a..4b2c4bb 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -47,17 +47,23 @@ struct error : public source_base auto controller = coordinator.get_output().get_worker(); auto exception = initial.exception; - controller.schedule( - [=](const rxsc::schedulable&){ - auto& dest = o; - if (!dest.is_subscribed()) { - // terminate loop - return; - } - - dest.on_error(exception); - // o is unsubscribed - }); + auto producer = [=](const rxsc::schedulable&){ + auto& dest = o; + if (!dest.is_subscribed()) { + // terminate loop + return; + } + + dest.on_error(exception); + // o is unsubscribed + }; + auto selectedProducer = on_exception( + [&](){return coordinator.act(producer);}, + o); + if (selectedProducer.empty()) { + return; + } + controller.schedule(selectedProducer.get()); } }; @@ -82,8 +88,8 @@ auto make_error(throw_instance_tag&&, E e, Coordination cn) template auto error(E e) - -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_one_worker(rxsc::make_immediate()))) { - return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_one_worker(rxsc::make_immediate())); + -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_immediate())) { + return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_immediate()); } template auto error(E e, Coordination cn) diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 7916359..4860acc 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -52,29 +52,50 @@ struct interval : public source_base auto counter = std::make_shared(0); - controller.schedule_periodically( - initial.initial, - initial.period, - [o, counter](const rxsc::schedulable&) { - // send next value - o.on_next(++(*counter)); - }); + auto producer = [o, counter](const rxsc::schedulable&) { + // send next value + o.on_next(++(*counter)); + }; + + auto selectedProducer = on_exception( + [&](){return coordinator.act(producer);}, + o); + if (selectedProducer.empty()) { + return; + } + + controller.schedule_periodically(initial.initial, initial.period, selectedProducer.get()); } }; -template +template struct delay_resolution { typedef observable> type; }; +} +template +static auto interval(TimePoint when) + -> typename detail::delay_resolution::type { + auto cn = identity_current_thread(); + return observable>( + rxs::detail::interval(when, rxsc::scheduler::clock_type::duration::max(), cn)); + static_assert(std::is_convertible::value, "TimePoint must be convertible to rxsc::scheduler::clock_type::time_point"); +} +template +static auto interval(rxsc::scheduler::clock_type::time_point when, Coordination cn) + -> typename std::enable_if::value, + observable>>::type { + return observable>( + rxs::detail::interval(when, rxsc::scheduler::clock_type::duration::max(), std::move(cn))); } template static auto interval(rxsc::scheduler::clock_type::time_point initial, Duration period) - -> typename detail::delay_resolution::type { + -> typename std::enable_if::value, + typename detail::delay_resolution>::type::type { return observable>( - rxs::detail::interval(initial, period, identity_one_worker(rxsc::make_current_thread()))); - static_assert(std::is_convertible::value, "duration must be convertible to rxsc::scheduler::clock_type::duration"); + rxs::detail::interval(initial, period, identity_current_thread())); } template static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, Coordination cn) diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index a013488..23107da 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -94,32 +94,39 @@ struct iterate : public source_base::value_t // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); - iterate_state_type state(initial, std::move(o)); + iterate_state_type state(initial, o); auto controller = coordinator.get_worker(); - controller.schedule( - [state](const rxsc::schedulable& self){ - if (!state.out.is_subscribed()) { - // terminate loop - return; - } - - if (state.cursor != state.end) { - // send next value - state.out.on_next(*state.cursor); - ++state.cursor; - } - - if (state.cursor == state.end) { - state.out.on_completed(); - // o is unsubscribed - return; - } - - // tail recurse this same action to continue loop - self(); - }); + auto producer = [state](const rxsc::schedulable& self){ + if (!state.out.is_subscribed()) { + // terminate loop + return; + } + + if (state.cursor != state.end) { + // send next value + state.out.on_next(*state.cursor); + ++state.cursor; + } + + if (state.cursor == state.end) { + state.out.on_completed(); + // o is unsubscribed + return; + } + + // tail recurse this same action to continue loop + self(); + }; + auto selectedProducer = on_exception( + [&](){return coordinator.act(producer);}, + o); + if (selectedProducer.empty()) { + return; + } + controller.schedule(selectedProducer.get()); + } }; @@ -129,7 +136,7 @@ template auto iterate(Collection c) -> observable::value_type, detail::iterate> { return observable::value_type, detail::iterate>( - detail::iterate(std::move(c), identity_one_worker(rxsc::make_current_thread()))); + detail::iterate(std::move(c), identity_immediate())); } template auto iterate(Collection c, Coordination cn) @@ -140,8 +147,8 @@ auto iterate(Collection c, Coordination cn) template auto from() - -> decltype(iterate(std::array(), identity_one_worker(rxsc::make_immediate()))) { - return iterate(std::array(), identity_one_worker(rxsc::make_immediate())); + -> decltype(iterate(std::array(), identity_immediate())) { + return iterate(std::array(), identity_immediate()); } template auto from(Coordination cn) @@ -152,9 +159,9 @@ auto from(Coordination cn) template auto from(Value0 v0, ValueN... vn) -> typename std::enable_if::value, - decltype(iterate(std::array(), identity_one_worker(rxsc::make_immediate())))>::type { + decltype(iterate(std::array(), identity_immediate()))>::type { std::array c = {v0, vn...}; - return iterate(std::move(c), identity_one_worker(rxsc::make_immediate())); + return iterate(std::move(c), identity_immediate()); } template auto from(Coordination cn, Value0 v0, ValueN... vn) diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index f304d6f..ec7ddf5 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -51,8 +51,7 @@ struct range : public source_base auto state = initial; - controller.schedule( - [=](const rxsc::schedulable& self){ + auto producer = [=](const rxsc::schedulable& self){ auto& dest = o; if (!dest.is_subscribed()) { // terminate loop @@ -78,7 +77,16 @@ struct range : public source_base // tail recurse this same action to continue loop self(); - }); + }; + + auto selectedProducer = on_exception( + [&](){return coordinator.act(producer);}, + o); + if (selectedProducer.empty()) { + return; + } + + controller.schedule(selectedProducer.get()); } }; @@ -88,7 +96,7 @@ template auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1) -> observable> { return observable>( - detail::range(first, last, step, identity_one_worker(rxsc::make_current_thread()))); + detail::range(first, last, step, identity_current_thread())); } template auto range(T first, T last, ptrdiff_t step, Coordination cn) diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index a128016..f00036a 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -203,12 +203,15 @@ class synchronize_in_one_worker : public coordination_base , coordination(factory) { } - rxsc::worker get_worker() const { + inline rxsc::worker get_worker() const { return controller; } - rxsc::scheduler get_scheduler() const { + inline rxsc::scheduler get_scheduler() const { return factory; } + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } template auto in(Observable o) const -> decltype(o.synchronize(coordination).ref_count()) { @@ -232,12 +235,26 @@ public: typedef coordinator coordinator_type; - coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } + + inline coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { auto w = factory.create_worker(std::move(cs)); return coordinator_type(input_type(std::move(w))); } }; +inline synchronize_in_one_worker synchronize_event_loop() { + static synchronize_in_one_worker r(rxsc::make_event_loop()); + return r; +} + +inline synchronize_in_one_worker synchronize_new_thread() { + static synchronize_in_one_worker r(rxsc::make_new_thread()); + return r; +} + } #endif diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index 34d2a4c..83354ef 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -1,4 +1,5 @@ #include "rxcpp/rx.hpp" +namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxsc=rxcpp::schedulers; @@ -619,3 +620,4 @@ SCENARIO("take, dispose after", "[take][operators]"){ } } } + -- GitLab From 0f1c6ab7ef34495922d58747b72b098e930387b6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 2 Jul 2014 18:18:39 -0700 Subject: [PATCH 368/782] add println utility --- Rx/v2/examples/println/main.cpp | 66 +++++++++++++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-util.hpp | 23 ++++++++++++ projects/CMake/CMakeLists.txt | 7 ++++ 3 files changed, 96 insertions(+) create mode 100644 Rx/v2/examples/println/main.cpp diff --git a/Rx/v2/examples/println/main.cpp b/Rx/v2/examples/println/main.cpp new file mode 100644 index 0000000..33598a5 --- /dev/null +++ b/Rx/v2/examples/println/main.cpp @@ -0,0 +1,66 @@ +#include "rxcpp/rx.hpp" +// create alias' to simplify code +// these are owned by the user so that +// conflicts can be managed by the user. +namespace rx=rxcpp; +namespace rxu=rxcpp::util; + +// At this time, RxCpp will fail to compile if the contents +// of the std namespace are merged into the global namespace +// DO NOT USE: 'using namespace std;' + +#if 0 +// +// println will insert values into the specified stream +// +template +struct println_function +{ + OStream& os; + println_function(OStream& os) : os(os) {} + + template + void operator()(const TN&... tn) const { + bool inserts[] = {(os << tn, true)...}; + os << std::endl; + } + + template + void operator()(const std::tuple& tpl) const { + apply(tpl, *this); + } +}; +template +auto println(OStream& os) + -> println_function { + return println_function(os); +} +#endif + +#ifdef UNICODE +int wmain(int argc, wchar_t** argv) +#else +int main(int argc, char** argv) +#endif +{ + auto get_names = [](){return rx::observable<>::from( + "Matthew", + "Aaron" + );}; + + std::cout << "===== println stream of std::string =====" << std::endl; + auto hello_str = [&](){return get_names().map([](std::string n){ + return "Hello, " + n + "!"; + });}; + + hello_str().subscribe(rxu::println(std::cout)); + + std::cout << "===== println stream of std::tuple =====" << std::endl; + auto hello_tpl = [&](){return get_names().map([](std::string n){ + return std::make_tuple("Hello, ", n, "! (", n.size(), ")"); + });}; + + hello_tpl().subscribe(rxu::println(std::cout)); + + return 0; +} diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index e30ff7f..713c5a3 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -160,6 +160,29 @@ inline auto pack() return detail::pack(); } +template +struct println_function +{ + OStream& os; + println_function(OStream& os) : os(os) {} + + template + void operator()(const TN&... tn) const { + bool inserts[] = {(os << tn, true)...}; + os << std::endl; + } + + template + void operator()(const std::tuple& tpl) const { + apply(tpl, *this); + } +}; +template +auto println(OStream& os) + -> println_function { + return println_function(os); +} + namespace detail { template diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index de7e3f3..4edfb22 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -67,6 +67,13 @@ set(PYTHAGORIAN_SOURCES add_executable(pythagorian ${PYTHAGORIAN_SOURCES}) TARGET_LINK_LIBRARIES(pythagorian ${CMAKE_THREAD_LIBS_INIT}) +# define the sources of the pythagorian example +set(PRINTLN_SOURCES + ${EXAMPLES_DIR}/println/main.cpp +) +add_executable(println ${PRINTLN_SOURCES}) +TARGET_LINK_LIBRARIES(println ${CMAKE_THREAD_LIBS_INIT}) + # configure unit tests via CTest enable_testing() -- GitLab From 67dbf832a1790a5f5a89f5c7f9abb6b7ee404c87 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 2 Jul 2014 18:20:11 -0700 Subject: [PATCH 369/782] rename synchronize to publish_synchronize --- Rx/v2/src/rxcpp/rx-observable.hpp | 11 ++++++----- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 4 ++-- Rx/v2/test/subscriptions/subscription.cpp | 6 +++--- 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 1d4bc1d..3720699 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -636,11 +636,12 @@ public: rxo::detail::multicast(*this, std::move(sub))); } - /// synchronize -> - /// turns a cold observable hot and allows connections to the source to be independent of subscriptions + /// publish_synchronized -> + /// turns a cold observable hot and allows connections to the source to be independent of subscriptions. + /// all values are queued and delivered using the scheduler from the supplied coordination /// template - auto synchronize(Coordination cn, composite_subscription cs = composite_subscription()) const + auto publish_synchronized(Coordination cn, composite_subscription cs = composite_subscription()) const -> decltype(EXPLICIT_THIS multicast(rxsub::synchronize(std::move(cn), cs))) { return multicast(rxsub::synchronize(std::move(cn), cs)); } @@ -800,7 +801,7 @@ public: /// take_until -> /// All sources must be synchronized! This means that calls across all the subscribers must be serial. - /// for each item from this observable until on_next occurs on the TriggerSource, emit them from the new observable that is returned. + /// for each item from this observable until the specified time, emit them from the new observable that is returned. /// /// template @@ -813,7 +814,7 @@ public: /// take_until -> /// The coordination is used to synchronize sources from different contexts. - /// for each item from this observable until on_next occurs on the TriggerSource, emit them from the new observable that is returned. + /// for each item from this observable until the specified time, emit them from the new observable that is returned. /// /// template diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index f00036a..c28fa91 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -214,8 +214,8 @@ class synchronize_in_one_worker : public coordination_base } template auto in(Observable o) const - -> decltype(o.synchronize(coordination).ref_count()) { - return o.synchronize(coordination).ref_count(); + -> decltype(o.publish_synchronized(coordination).ref_count()) { + return o.publish_synchronized(coordination).ref_count(); } template auto out(Subscriber s) const diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 783a774..289e12c 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -139,7 +139,7 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto s0 = rxs::range(0, 499, 1, es) .lift(liftrequirecompletion) .as_dynamic() - .synchronize(es) + .publish_synchronized(es) .ref_count() .lift(liftrequirecompletion) .subscribe( @@ -153,7 +153,7 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto s1 = rxs::range(500, 999, 1, es) .lift(liftrequirecompletion) .as_dynamic() - .synchronize(es) + .publish_synchronized(es) .ref_count() .lift(liftrequirecompletion) .subscribe( @@ -167,7 +167,7 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto s2 = rxs::range(1000, 1499, 1, es) .lift(liftrequirecompletion) .as_dynamic() - .synchronize(es) + .publish_synchronized(es) .ref_count() .lift(liftrequirecompletion) .subscribe( -- GitLab From b8274a13bfa9e0e13e157410d4a889ea7c6f5151 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 2 Jul 2014 18:20:45 -0700 Subject: [PATCH 370/782] cleanup alias' --- Rx/v2/examples/pythagorian/main.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/Rx/v2/examples/pythagorian/main.cpp b/Rx/v2/examples/pythagorian/main.cpp index d6aa6f0..2fd1fdf 100644 --- a/Rx/v2/examples/pythagorian/main.cpp +++ b/Rx/v2/examples/pythagorian/main.cpp @@ -4,8 +4,6 @@ // conflicts can be managed by the user. namespace rx=rxcpp; namespace rxu=rxcpp::util; -namespace rxsc=rxcpp::schedulers; -namespace rxsub=rxcpp::subjects; // At this time, RxCpp will fail to compile if the contents // of the std namespace are merged into the global namespace -- GitLab From 53241dc32fee709e2dcb136f1a6c09780708d2b7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 3 Jul 2014 00:28:04 -0700 Subject: [PATCH 371/782] add observe_on still has at least one race condition --- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 271 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 9 + Rx/v2/src/rxcpp/rx-observer.hpp | 2 +- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/concat.cpp | 48 +++- Rx/v2/test/operators/flat_map.cpp | 71 ++++- Rx/v2/test/operators/merge.cpp | 48 +++- Rx/v2/test/operators/observe_on.cpp | 50 ++++ Rx/v2/test/subjects/subject.cpp | 2 +- projects/CMake/CMakeLists.txt | 1 + 10 files changed, 479 insertions(+), 24 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-observe_on.hpp create mode 100644 Rx/v2/test/operators/observe_on.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp new file mode 100644 index 0000000..889c329 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -0,0 +1,271 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_OBSERVE_ON_HPP) +#define RXCPP_OPERATORS_RX_OBSERVE_ON_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct observe_on +{ + typedef typename std::decay::type source_value_type; + + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + + coordination_type coordination; + + observe_on(coordination_type cn) + : coordination(std::move(cn)) + { + } + + template + struct observe_on_observer : public observer_base + { + typedef observe_on_observer this_type; + typedef observer_base base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + + typedef rxn::notification notification_type; + typedef typename notification_type::type base_notification_type; + typedef std::queue queue_type; + + struct mode + { + enum type { + Invalid = 0, + Processing, + Empty, + Disposed + }; + }; + struct observe_on_state : std::enable_shared_from_this + { + mutable std::mutex lock; + mutable queue_type queue; + mutable queue_type drain_queue; + composite_subscription lifetime; + rxsc::worker processor; + mutable typename mode::type current; + coordinator_type coordinator; + dest_type destination; + + observe_on_state(dest_type d, coordinator_type coor, composite_subscription cs) + : lifetime(std::move(cs)) + , current(mode::Empty) + , coordinator(std::move(coor)) + , destination(std::move(d)) + { + } + + void ensure_processing(std::unique_lock& guard) const { + if (!guard.owns_lock()) { + abort(); + } + if (current == mode::Empty) { + current = mode::Processing; + auto keepAlive = this->shared_from_this(); + + auto drain = [keepAlive, this](const rxsc::schedulable& self){ + try { + if (drain_queue.empty() || !destination.is_subscribed()) { + std::unique_lock guard(lock); + if (!destination.is_subscribed() || + (!lifetime.is_subscribed() && queue.empty())) { + current = mode::Disposed; + using std::swap; + queue_type expired; + swap(expired, queue); + guard.unlock(); + lifetime.unsubscribe(); + destination.unsubscribe(); + return; + } + if (queue.empty()) { + current = mode::Empty; + return; + } + using std::swap; + swap(queue, drain_queue); + } + auto notification = std::move(drain_queue.front()); + drain_queue.pop(); + notification->accept(destination); + self(); + } catch(...) { + destination.on_error(std::current_exception()); + std::unique_lock guard(lock); + current = mode::Empty; + } + }; + + auto selectedDrain = on_exception( + [&](){return coordinator.act(drain);}, + destination); + if (selectedDrain.empty()) { + return; + } + + auto processor = coordinator.get_worker(); + processor.schedule(lifetime, selectedDrain.get()); + } + } + }; + std::shared_ptr state; + + observe_on_observer(dest_type d, coordinator_type coor, composite_subscription cs) + : state(std::make_shared(std::move(d), std::move(coor), std::move(cs))) + { + } + + void on_next(source_value_type v) const { + if (state->lifetime.is_subscribed()) { + std::unique_lock guard(state->lock); + state->queue.push(notification_type::on_next(std::move(v))); + state->ensure_processing(guard); + } + } + void on_error(std::exception_ptr e) const { + if (state->lifetime.is_subscribed()) { + std::unique_lock guard(state->lock); + state->queue.push(notification_type::on_error(e)); + state->ensure_processing(guard); + } + } + void on_completed() const { + if (state->lifetime.is_subscribed()) { + std::unique_lock guard(state->lock); + state->queue.push(notification_type::on_completed()); + state->ensure_processing(guard); + } + } + + static subscriber make(dest_type d, coordination_type cn, composite_subscription cs = composite_subscription()) { + auto coor = cn.create_coordinator(d.get_subscription()); + d.add(cs); + + this_type o(d, std::move(coor), cs); + auto keepAlive = o.state; + cs.add([keepAlive](){ + std::unique_lock guard(keepAlive->lock); + keepAlive->ensure_processing(guard); + }); + + return make_subscriber(cs, std::move(o)); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(observe_on_observer::make(dest.as_dynamic(), coordination)) { + return observe_on_observer::make(dest.as_dynamic(), coordination); + } +}; + +template +class observe_on_factory +{ + typedef typename std::decay::type coordination_type; + coordination_type coordination; +public: + observe_on_factory(coordination_type cn) : coordination(std::move(cn)) {} + template + auto operator()(Observable&& source) + -> decltype(source.lift(observe_on::type::value_type, coordination_type>(coordination))) { + return source.lift(observe_on::type::value_type, coordination_type>(coordination)); + } +}; + +} + +template +auto observe_on(Coordination cn) + -> detail::observe_on_factory { + return detail::observe_on_factory(std::move(cn)); +} + + +} + +class observe_on_one_worker : public coordination_base +{ + rxsc::scheduler factory; + + class input_type + { + rxsc::worker controller; + rxsc::scheduler factory; + identity_one_worker coordination; + public: + explicit input_type(rxsc::worker w) + : controller(w) + , factory(rxsc::make_same_worker(w)) + , coordination(factory) + { + } + inline rxsc::worker get_worker() const { + return controller; + } + inline rxsc::scheduler get_scheduler() const { + return factory; + } + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } + template + auto in(Observable o) const + -> decltype(o.observe_on(coordination)) { + return o.observe_on(coordination); + } + template + auto out(Subscriber s) const + -> Subscriber { + return std::move(s); + } + template + auto act(F f) const + -> F { + return std::move(f); + } + }; + +public: + + explicit observe_on_one_worker(rxsc::scheduler sc) : factory(sc) {} + + typedef coordinator coordinator_type; + + inline rxsc::scheduler::clock_type::time_point now() const { + return factory.now(); + } + + inline coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const { + auto w = factory.create_worker(std::move(cs)); + return coordinator_type(input_type(std::move(w))); + } +}; + +inline observe_on_one_worker observe_on_event_loop() { + static observe_on_one_worker r(rxsc::make_event_loop()); + return r; +} + +inline observe_on_one_worker observe_on_new_thread() { + static observe_on_one_worker r(rxsc::make_new_thread()); + return r; +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 3720699..4a016d8 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -664,6 +664,15 @@ public: return multicast(rxsub::behavior(first, cs)); } + /// observe_on -> + /// all values are queued and delivered using the scheduler from the supplied coordination + /// + template + auto observe_on(Coordination cn) const + -> decltype(EXPLICIT_THIS lift(rxo::detail::observe_on(std::move(cn)))) { + return lift(rxo::detail::observe_on(std::move(cn))); + } + /// reduce -> /// for each item from this observable use Accumulator to combine items, when completed use ResultSelector to produce a value that will be emitted from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 2dff1e8..12d151d 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -172,7 +172,7 @@ private: template static auto make_destination(Observer o) - -> typename std::enable_if::value, std::shared_ptr>::type { + -> std::shared_ptr { return std::make_shared>(std::move(o)); } diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index cd9410f..4ee9865 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -46,6 +46,7 @@ namespace rxo=operators; #include "operators/rx-map.hpp" #include "operators/rx-merge.hpp" #include "operators/rx-multicast.hpp" +#include "operators/rx-observe_on.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-reduce.hpp" #include "operators/rx-ref_count.hpp" diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 619894a..e4c23b7 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -9,7 +9,6 @@ namespace rxsc=rxcpp::schedulers; const int static_onnextcalls = 1000000; - SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("some ranges"){ @@ -20,9 +19,7 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::synchronize_in_one_worker(sc); + auto so = rx::synchronize_event_loop(); std::atomic c(0); int n = 1; @@ -51,6 +48,45 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" } } +SCENARIO("observe_on concat ranges", "[hide][range][observe_on][concat][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("some ranges"){ + WHEN("generating ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto so = rx::observe_on_event_loop(); + + std::atomic c(0); + int n = 1; + auto sectionCount = onnextcalls / 3; + auto start = clock::now(); + rxs::range(0, sectionCount - 1, 1, so) + .concat( + so, + rxs::range(sectionCount, sectionCount * 2 - 1, 1, so), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) + .subscribe( + [&c](int x){ + ++c;}, + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return c == onnextcalls;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat observe_on ranges : " << n << " subscribed, " << c << " emitted, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + SCENARIO("serialize concat ranges", "[hide][range][serialize][concat][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("some ranges"){ @@ -61,9 +97,7 @@ SCENARIO("serialize concat ranges", "[hide][range][serialize][concat][perf]"){ std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::serialize_one_worker(sc); + auto so = rx::serialize_event_loop(); std::atomic c(0); int n = 1; diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 0179909..6999a14 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -53,9 +53,7 @@ SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][pe using namespace std::chrono; typedef steady_clock clock; - auto sc = rxsc::make_immediate(); - //auto sc = rxsc::make_current_thread(); - auto so = rx::identity_one_worker(sc); + auto so = rx::identity_immediate(); int c = 0; int ct = 0; @@ -101,9 +99,7 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::synchronize_in_one_worker(sc); + auto so = rx::synchronize_event_loop(); int c = 0; std::atomic ct(0); @@ -152,6 +148,65 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn } } +SCENARIO("observe_on flat_map pythagorian ranges", "[hide][range][flat_map][observe_on][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto so = rx::observe_on_event_loop(); + + int c = 0; + std::atomic ct(0); + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, so) + .flat_map( + [&c, so](int z){ + return rxs::range(1, z, 1, so) + .flat_map( + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) + .filter([&c, z, x](int y){ + ++c; + if (x*x + y*y == z*z) { + return true;} + else { + return false;}}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}, + so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}, + so); + triples + .take(tripletCount) + .subscribe( + rxu::apply_to([&ct](int x,int y,int z){ + ++ct;}), + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return ct == tripletCount;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "merge observe_on pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + } + } +} + SCENARIO("serialize flat_map pythagorian ranges", "[hide][range][flat_map][serialize][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; GIVEN("some ranges"){ @@ -162,9 +217,7 @@ SCENARIO("serialize flat_map pythagorian ranges", "[hide][range][flat_map][seria std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::serialize_one_worker(sc); + auto so = rx::serialize_event_loop(); int c = 0; std::atomic ct(0); diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index 73af651..a964b0e 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -20,9 +20,7 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::synchronize_in_one_worker(sc); + auto so = rx::synchronize_event_loop(); std::atomic c(0); int n = 1; @@ -52,6 +50,46 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ } } +SCENARIO("observe_on merge ranges", "[hide][range][observe_on][merge][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("some ranges"){ + WHEN("generating ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto so = rx::observe_on_event_loop(); + + std::atomic c(0); + int n = 1; + auto sectionCount = onnextcalls / 3; + auto start = clock::now(); + rxs::range(0, sectionCount - 1, 1, so) + .merge( + so, + rxs::range(sectionCount, (sectionCount * 2) - 1, 1, so), + rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) + .subscribe( + [&c](int x){ + ++c;}, + [](std::exception_ptr){abort();}, + [&](){ + wake.notify_one(); + }); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return c == onnextcalls;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "merge observe_on ranges : " << n << " subscribed, " << c << " emitted, " << msElapsed.count() << "ms elapsed " << std::endl; + } + } +} + SCENARIO("serialize merge ranges", "[hide][range][serialize][merge][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("some ranges"){ @@ -62,9 +100,7 @@ SCENARIO("serialize merge ranges", "[hide][range][serialize][merge][perf]"){ std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::serialize_one_worker(sc); + auto so = rx::serialize_event_loop(); std::atomic c(0); int n = 1; diff --git a/Rx/v2/test/operators/observe_on.cpp b/Rx/v2/test/operators/observe_on.cpp new file mode 100644 index 0000000..574fdfb --- /dev/null +++ b/Rx/v2/test/operators/observe_on.cpp @@ -0,0 +1,50 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; +namespace rxsub=rxcpp::subjects; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +const int static_onnextcalls = 100000; +static int aliased = 0; + +SCENARIO("range observed on current_thread", "[hide][range][observe_on][long][perf]"){ + const int& onnextcalls = static_onnextcalls; + GIVEN("a range"){ + WHEN("multicasting a million ints"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto el = rx::observe_on_new_thread(); + + for (int n = 0; n < 10; n++) + { + std::atomic_bool done(false); + auto c = std::make_shared(0); + + auto start = clock::now(); + rxs::range(1) + .take(onnextcalls) + .observe_on(el) + .subscribe( + [c](int){ + ++(*c); + }, + [&](){ + done = true; + }); + while(!done) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + auto expected = onnextcalls; + REQUIRE(*c == expected); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "range -> observe_on current_thread : " << (*c) << " on_next calls, " << msElapsed.count() << "ms elapsed, int-per-second " << *c / (msElapsed.count() / 1000.0) << std::endl; + } + } + } +} diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index 4d8faf7..ea2230a 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -14,7 +14,7 @@ namespace rxsub=rxcpp::subjects; const int static_onnextcalls = 100000000; -int aliased = 0; +static int aliased = 0; SCENARIO("for loop locks mutex", "[hide][for][mutex][long][perf]"){ const int& onnextcalls = static_onnextcalls; diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 4edfb22..a34de7f 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -45,6 +45,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/lift.cpp ${TEST_DIR}/operators/map.cpp ${TEST_DIR}/operators/merge.cpp + ${TEST_DIR}/operators/observe_on.cpp ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/repeat.cpp -- GitLab From 493950d100777f0150921f83667574541a1bd174 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 7 Jul 2014 08:20:59 -0700 Subject: [PATCH 372/782] fix crazy subtle concurrency bug returning an observer instead of a subscriber. caused a break in the lifetime nesting that due to tests referencing stack vars caused weird stack stomping. --- Rx/v2/src/rxcpp/rx-coordination.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index 1a3c6f3..cbe030d 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -260,8 +260,8 @@ class serialize_one_worker : public coordination_base } template auto out(Subscriber s) const - -> serialize_observer { - return serialize_observer(std::move(s), lock); + -> decltype(serialize_observer::make(std::move(s), lock)) { + return serialize_observer::make(std::move(s), lock); } template auto act(F f) const -- GitLab From 81936ceeca7e09099dc881731a21e306d2ffad29 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 7 Jul 2014 08:22:52 -0700 Subject: [PATCH 373/782] connect coordinators to subscriber lifetime --- Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index 61d0d47..9a0b057 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -167,7 +167,7 @@ struct combine_latest : public operator_base(new combine_latest_state_type(initial, std::move(coordinator), std::move(scbr))); diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index a1f9061..98cec31 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -180,7 +180,7 @@ struct concat_map output_type out; }; - auto coordinator = initial.coordination.create_coordinator(); + auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription auto state = std::shared_ptr(new concat_map_state_type(initial, std::move(coordinator), std::move(scbr))); diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 1906724..84aeb66 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -111,7 +111,7 @@ struct flat_map output_type out; }; - auto coordinator = initial.coordination.create_coordinator(); + auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(scbr))); diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 684a13c..3b980ad 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -71,7 +71,7 @@ struct merge output_type out; }; - auto coordinator = initial.coordination.create_coordinator(); + auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription auto state = std::shared_ptr(new merge_state_type(initial, std::move(coordinator), std::move(scbr))); diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp index b47fd12..b8c63a4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -72,7 +72,7 @@ struct switch_on_next output_type out; }; - auto coordinator = initial.coordination.create_coordinator(); + auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription auto state = std::shared_ptr(new switch_state_type(initial, std::move(coordinator), std::move(scbr))); diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index 2f25e74..b1fb8ff 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -74,7 +74,7 @@ struct take_until : public operator_base output_type out; }; - auto coordinator = initial.coordination.create_coordinator(); + auto coordinator = initial.coordination.create_coordinator(s.get_subscription()); // take a copy of the values for each subscription auto state = std::shared_ptr(new take_until_state_type(initial, std::move(coordinator), std::move(s))); -- GitLab From 22cdb4f0ff321501a2ac8e8ddcbdc989d3ab6ba1 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 7 Jul 2014 08:33:33 -0700 Subject: [PATCH 374/782] fix deadlock, error and dispose --- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 63 ++++++++++++--------- 1 file changed, 37 insertions(+), 26 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 889c329..001a4e2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -47,7 +47,8 @@ struct observe_on Invalid = 0, Processing, Empty, - Disposed + Disposed, + Errored }; }; struct observe_on_state : std::enable_shared_from_this @@ -75,16 +76,17 @@ struct observe_on } if (current == mode::Empty) { current = mode::Processing; + auto keepAlive = this->shared_from_this(); auto drain = [keepAlive, this](const rxsc::schedulable& self){ + using std::swap; try { if (drain_queue.empty() || !destination.is_subscribed()) { std::unique_lock guard(lock); if (!destination.is_subscribed() || - (!lifetime.is_subscribed() && queue.empty())) { + (!lifetime.is_subscribed() && queue.empty() && drain_queue.empty())) { current = mode::Disposed; - using std::swap; queue_type expired; swap(expired, queue); guard.unlock(); @@ -92,12 +94,13 @@ struct observe_on destination.unsubscribe(); return; } - if (queue.empty()) { - current = mode::Empty; - return; + if (drain_queue.empty()) { + if (queue.empty()) { + current = mode::Empty; + return; + } + swap(queue, drain_queue); } - using std::swap; - swap(queue, drain_queue); } auto notification = std::move(drain_queue.front()); drain_queue.pop(); @@ -106,7 +109,9 @@ struct observe_on } catch(...) { destination.on_error(std::current_exception()); std::unique_lock guard(lock); - current = mode::Empty; + current = mode::Errored; + queue_type expired; + swap(expired, queue); } }; @@ -114,11 +119,20 @@ struct observe_on [&](){return coordinator.act(drain);}, destination); if (selectedDrain.empty()) { + std::unique_lock guard(lock); + current = mode::Errored; + using std::swap; + queue_type expired; + swap(expired, queue); return; } auto processor = coordinator.get_worker(); - processor.schedule(lifetime, selectedDrain.get()); + + RXCPP_UNWIND_AUTO([&](){guard.lock();}); + guard.unlock(); + + processor.schedule(selectedDrain.get()); } } }; @@ -130,25 +144,19 @@ struct observe_on } void on_next(source_value_type v) const { - if (state->lifetime.is_subscribed()) { - std::unique_lock guard(state->lock); - state->queue.push(notification_type::on_next(std::move(v))); - state->ensure_processing(guard); - } + std::unique_lock guard(state->lock); + state->queue.push(notification_type::on_next(std::move(v))); + state->ensure_processing(guard); } void on_error(std::exception_ptr e) const { - if (state->lifetime.is_subscribed()) { - std::unique_lock guard(state->lock); - state->queue.push(notification_type::on_error(e)); - state->ensure_processing(guard); - } + std::unique_lock guard(state->lock); + state->queue.push(notification_type::on_error(e)); + state->ensure_processing(guard); } void on_completed() const { - if (state->lifetime.is_subscribed()) { - std::unique_lock guard(state->lock); - state->queue.push(notification_type::on_completed()); - state->ensure_processing(guard); - } + std::unique_lock guard(state->lock); + state->queue.push(notification_type::on_completed()); + state->ensure_processing(guard); } static subscriber make(dest_type d, coordination_type cn, composite_subscription cs = composite_subscription()) { @@ -159,7 +167,10 @@ struct observe_on auto keepAlive = o.state; cs.add([keepAlive](){ std::unique_lock guard(keepAlive->lock); - keepAlive->ensure_processing(guard); + if (keepAlive->queue.empty() && keepAlive->current == mode::Empty && keepAlive->destination.is_subscribed()) { + keepAlive->current = mode::Disposed; + keepAlive->destination.unsubscribe(); + } }); return make_subscriber(cs, std::move(o)); -- GitLab From 4b2bb44cf2e9b6a2dc289beec0ac983a950c3baa Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 7 Jul 2014 08:35:29 -0700 Subject: [PATCH 375/782] add some moves --- Rx/v2/src/rxcpp/rx-scheduler.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index e0a2a16..3596a0e 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -357,7 +357,7 @@ public: { } explicit scheduler(detail::const_scheduler_interface_ptr i) - : inner(std::const_pointer_cast(i)) + : inner(std::move(std::const_pointer_cast(i))) { } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp b/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp index 1059930..5b3ff4e 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp @@ -21,7 +21,7 @@ private: public: explicit same_worker(rxsc::worker w) - : controller(w) + : controller(std::move(w)) { } virtual ~same_worker() @@ -42,7 +42,7 @@ public: }; inline scheduler make_same_worker(rxsc::worker w) { - auto i = make_scheduler(w); + auto i = make_scheduler(std::move(w)); return i; } -- GitLab From 5466ddda76442374e3d90a28599c7bf9a6bd3869 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 7 Jul 2014 08:36:31 -0700 Subject: [PATCH 376/782] test updates --- Rx/v2/test/operators/concat_map.cpp | 89 ++++++++++-- Rx/v2/test/operators/flat_map.cpp | 5 +- Rx/v2/test/operators/observe_on.cpp | 15 +- Rx/v2/test/subscriptions/subscription.cpp | 166 ++++++++++++++++++---- 4 files changed, 232 insertions(+), 43 deletions(-) diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 4f6b675..3c4c486 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -64,9 +64,7 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::synchronize_in_one_worker(sc); + auto so = rx::synchronize_event_loop(); int c = 0; std::atomic ct(0); @@ -115,6 +113,74 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] } } +SCENARIO("observe_on concat_map pythagorian ranges", "[hide][range][concat_map][observe_on][pythagorian][perf]"){ + const int& tripletCount = static_tripletCount; + GIVEN("some ranges"){ + WHEN("generating pythagorian triplets"){ + using namespace std::chrono; + typedef steady_clock clock; + + std::mutex lock; + std::condition_variable wake; + + auto so = rx::observe_on_event_loop(); + + int c = 0; + std::atomic_bool done(false); + std::atomic_bool disposed(false); + std::atomic ct(0); + int n = 1; + auto start = clock::now(); + auto triples = + rxs::range(1, so) + .concat_map( + [&c, so](int z){ + return rxs::range(1, z, 1, so) + .concat_map( + [&c, so, z](int x){ + return rxs::range(x, z, 1, so) + .filter([&c, z, x](int y){ + ++c; + if (x*x + y*y == z*z) { + return true;} + else { + return false;}}) + .map([z, x](int y){return std::make_tuple(x, y, z);}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int x, std::tuple triplet){return triplet;}, + so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic();}, + [](int z, std::tuple triplet){return triplet;}, + so); + + rx::composite_subscription cs; + cs.add([&](){ + disposed = true; + wake.notify_one();}); + + triples + .take(tripletCount) + .subscribe( + cs, + rxu::apply_to([&ct](int x,int y,int z){ + ++ct;}), + [&](){ + done = true; + wake.notify_one();}); + + std::unique_lock guard(lock); + wake.wait(guard, [&](){return ct == tripletCount && done && disposed;}); + + auto finish = clock::now(); + auto msElapsed = duration_cast(finish.time_since_epoch()) - + duration_cast(start.time_since_epoch()); + std::cout << "concat observe_on pythagorian range : " << n << " subscribed, " << c << " filtered to, " << ct << " triplets, " << msElapsed.count() << "ms elapsed " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + } + } +} + SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][serialize][pythagorian][perf]"){ const int& tripletCount = static_tripletCount; GIVEN("some ranges"){ @@ -125,11 +191,11 @@ SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][s std::mutex lock; std::condition_variable wake; - auto sc = rxsc::make_event_loop(); - //auto sc = rxsc::make_new_thread(); - auto so = rx::serialize_one_worker(sc); + auto so = rx::serialize_event_loop(); int c = 0; + std::atomic_bool done(false); + std::atomic_bool disposed(false); std::atomic ct(0); int n = 1; auto start = clock::now(); @@ -156,17 +222,24 @@ SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][s .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}, so); + + rx::composite_subscription cs; + cs.add([&](){ + disposed = true; + wake.notify_one();}); + triples .take(tripletCount) .subscribe( + cs, rxu::apply_to([&ct](int x,int y,int z){ ++ct;}), - [](std::exception_ptr){abort();}, [&](){ + done = true; wake.notify_one();}); std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount;}); + wake.wait(guard, [&](){return ct == tripletCount && done && disposed;}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 6999a14..d32de54 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -78,8 +78,9 @@ SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][pe triples .take(tripletCount) .subscribe( - rxu::apply_to([&ct](int x,int y,int z){++ct;}), - [](std::exception_ptr){abort();}); + rxu::apply_to([&ct](int x,int y,int z){ + ++ct; + })); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - duration_cast(start.time_since_epoch()); diff --git a/Rx/v2/test/operators/observe_on.cpp b/Rx/v2/test/operators/observe_on.cpp index 574fdfb..5b3ac50 100644 --- a/Rx/v2/test/operators/observe_on.cpp +++ b/Rx/v2/test/operators/observe_on.cpp @@ -9,9 +9,8 @@ namespace rxsub=rxcpp::subjects; #include "catch.hpp" const int static_onnextcalls = 100000; -static int aliased = 0; -SCENARIO("range observed on current_thread", "[hide][range][observe_on][long][perf]"){ +SCENARIO("range observed on current_thread", "[hide][range][observe_on_debug][observe_on][long][perf]"){ const int& onnextcalls = static_onnextcalls; GIVEN("a range"){ WHEN("multicasting a million ints"){ @@ -22,23 +21,29 @@ SCENARIO("range observed on current_thread", "[hide][range][observe_on][long][pe for (int n = 0; n < 10; n++) { + std::atomic_bool disposed(false); std::atomic_bool done(false); auto c = std::make_shared(0); + rx::composite_subscription cs; + cs.add([&](){ + if (!done) {abort();} + disposed = true; + }); + auto start = clock::now(); rxs::range(1) .take(onnextcalls) .observe_on(el) .subscribe( + cs, [c](int){ ++(*c); }, [&](){ done = true; }); - while(!done) { - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - } + while(!done || !disposed); auto expected = onnextcalls; REQUIRE(*c == expected); auto finish = clock::now(); diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 289e12c..b979c4f 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -90,7 +90,7 @@ SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_lat } } -SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf]"){ +SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug][synchronize][long][perf]"){ GIVEN("range"){ WHEN("synchronized"){ using namespace std::chrono; @@ -99,8 +99,9 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf auto sc = rxsc::make_current_thread(); auto w = sc.create_worker(); - auto el = rxsc::make_event_loop(); - auto es = rx::synchronize_in_one_worker(el); + auto es = rx::synchronize_event_loop(); + + const int values = 10000; int runs = 10; @@ -108,35 +109,36 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf std::atomic c(0); int n = 1; auto liftrequirecompletion = [&](rx::subscriber dest){ - auto completionstate = std::make_shared>>(0, std::move(dest)); - completionstate->second.add([=](){ - if (completionstate->first != 500) { + auto completionstate = std::make_shared>>(false, 0, std::move(dest)); + std::get<2>(*completionstate).add([=](){ + if (std::get<1>(*completionstate) != values || !std::get<0>(*completionstate)) { abort(); } }); // VS2013 deduction issue requires dynamic (type-forgetting) return rx::make_subscriber( - completionstate->second, - rx::make_observer_dynamic( - [=](int n){ - ++completionstate->first; - completionstate->second.on_next(n); - }, - [=](std::exception_ptr e){ + std::get<2>(*completionstate), + [=](int n){ + ++std::get<1>(*completionstate); + std::get<2>(*completionstate).on_next(n); + }, + [=](std::exception_ptr e){ + abort(); + std::get<2>(*completionstate).on_error(e); + }, + [=](){ + if (std::get<1>(*completionstate) != values) { abort(); - completionstate->second.on_error(e); - }, - [=](){ - if (completionstate->first != 500) { - abort(); - } - completionstate->second.on_completed(); - })); + } + std::get<0>(*completionstate) = true; + std::get<2>(*completionstate).on_completed(); + }).as_dynamic(); }; auto start = clock::now(); - auto ew = el.create_worker(); + auto ew = es.create_coordinator().get_worker(); std::atomic v(0); - auto s0 = rxs::range(0, 499, 1, es) + auto s0 = rxs::range(1, es) + .take(values) .lift(liftrequirecompletion) .as_dynamic() .publish_synchronized(es) @@ -150,7 +152,8 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf [&](){ ++c; })); - auto s1 = rxs::range(500, 999, 1, es) + auto s1 = rxs::range(values + 1, es) + .take(values) .lift(liftrequirecompletion) .as_dynamic() .publish_synchronized(es) @@ -164,7 +167,8 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf [&](){ ++c; })); - auto s2 = rxs::range(1000, 1499, 1, es) + auto s2 = rxs::range((values * 2) + 1, es) + .take(values) .lift(liftrequirecompletion) .as_dynamic() .publish_synchronized(es) @@ -178,13 +182,120 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf [&](){ ++c; })); - while(v != 1500 || c != 3); + while(v != values * 3 || c != 3); + s0.unsubscribe(); + s1.unsubscribe(); + s2.unsubscribe(); + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "range synchronized : " << n << " subscribed, " << v << " on_next calls, " << msElapsed.count() << "ms elapsed, " << v / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + + if (--runs > 0) { + self(); + } + }; + + w.schedule(loop); + } + } +} + +SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][observe_on][long][perf]"){ + GIVEN("range"){ + WHEN("observed on"){ + using namespace std::chrono; + typedef steady_clock clock; + + auto sc = rxsc::make_current_thread(); + auto w = sc.create_worker(); + + auto es = rx::observe_on_event_loop(); + + const int values = 10000; + + int runs = 10; + + auto loop = [&](const rxsc::schedulable& self) { + std::atomic c(0); + int n = 1; + auto liftrequirecompletion = [&](rx::subscriber dest){ + auto completionstate = std::make_shared>>(false, 0, std::move(dest)); + std::get<2>(*completionstate).add([=](){ + if (std::get<1>(*completionstate) != values || !std::get<0>(*completionstate)) { + abort(); + } + }); + // VS2013 deduction issue requires dynamic (type-forgetting) + return rx::make_subscriber( + std::get<2>(*completionstate), + [=](int n){ + ++std::get<1>(*completionstate); + std::get<2>(*completionstate).on_next(n); + }, + [=](std::exception_ptr e){ + abort(); + std::get<2>(*completionstate).on_error(e); + }, + [=](){ + if (std::get<1>(*completionstate) != values) { + abort(); + } + std::get<0>(*completionstate) = true; + std::get<2>(*completionstate).on_completed(); + }).as_dynamic(); + }; + auto start = clock::now(); + auto ew = es.create_coordinator().get_worker(); + std::atomic v(0); + auto s0 = rxs::range(1, es) + .take(values) + .lift(liftrequirecompletion) + .as_dynamic() + .observe_on(es) + .lift(liftrequirecompletion) + .subscribe( + rx::make_observer_dynamic( + [&](int i){ + ++v; + }, + [&](){ + ++c; + })); + auto s1 = rxs::range(values + 1, es) + .take(values) + .lift(liftrequirecompletion) + .as_dynamic() + .observe_on(es) + .lift(liftrequirecompletion) + .subscribe( + rx::make_observer_dynamic( + [&](int i){ + ++v; + }, + [&](){ + ++c; + })); + auto s2 = rxs::range((values * 2) + 1, es) + .take(values) + .lift(liftrequirecompletion) + .as_dynamic() + .observe_on(es) + .lift(liftrequirecompletion) + .subscribe( + rx::make_observer_dynamic( + [&](int i){ + ++v; + }, + [&](){ + ++c; + })); + while(v != values * 3 || c != 3); s0.unsubscribe(); s1.unsubscribe(); s2.unsubscribe(); auto finish = clock::now(); auto msElapsed = duration_cast(finish-start); - std::cout << "range synchronize : " << n << " subscribed, " << v << " on_next calls, " << msElapsed.count() << "ms elapsed, " << v / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + std::cout << "range observe_on : " << n << " subscribed, " << v << " on_next calls, " << msElapsed.count() << "ms elapsed, " << v / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; if (--runs > 0) { self(); @@ -198,7 +309,6 @@ SCENARIO("synchronized range", "[hide][subscribe][range][synchronize][long][perf SCENARIO("subscription traits", "[subscription][traits]"){ GIVEN("given some subscription types"){ - auto empty = [](){}; auto es = rx::make_subscription(); rx::composite_subscription cs; WHEN("tested"){ -- GitLab From b0a01c37ace98409bc0d5251212a06c1083139c1 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 8 Jul 2014 08:04:47 -0700 Subject: [PATCH 377/782] gcc 32bit runs out of address space and memory on combine_latest.cpp, split the tests up --- Rx/v2/test/operators/combine_latest.1.cpp | 730 ++++++++++++++++++ ...ombine_latest.cpp => combine_latest.2.cpp} | 723 ----------------- projects/CMake/CMakeLists.txt | 3 +- 3 files changed, 732 insertions(+), 724 deletions(-) create mode 100644 Rx/v2/test/operators/combine_latest.1.cpp rename Rx/v2/test/operators/{combine_latest.cpp => combine_latest.2.cpp} (56%) diff --git a/Rx/v2/test/operators/combine_latest.1.cpp b/Rx/v2/test/operators/combine_latest.1.cpp new file mode 100644 index 0000000..acf2e93 --- /dev/null +++ b/Rx/v2/test/operators/combine_latest.1.cpp @@ -0,0 +1,730 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(220, 3), + on.on_next(230, 5), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.on_next(220, 2 + 3), + on.on_next(225, 4 + 3), + on.on_next(230, 4 + 5), + on.on_next(235, 4 + 6), + on.on_next(240, 4 + 7), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest consecutive", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.on_next(235, 4 + 6), + on.on_next(240, 4 + 7), + on.on_completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest consecutive ends with error left", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_error(230, ex) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only an error"){ + auto required = rxu::to_vector({ + on.on_error(230, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest consecutive ends with error right", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("combine_latest on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_next(225, 4), + on.on_completed(250) + }); + + auto o2 = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(235, 6), + on.on_next(240, 7), + on.on_error(245, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints followed by an error"){ + auto required = rxu::to_vector({ + on.on_next(235, 4 + 6), + on.on_next(240, 4 + 7), + on.on_error(245, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 245) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 245) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest never N", "[combine_latest][join][operators]"){ + GIVEN("N never completed hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const size_t N = 16; + + std::vector> n; + for (int i = 0; i < N; ++i) { + n.push_back( + sc.make_hot_observable({ + on.on_next(150, 1) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n[0] + .combine_latest( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13], n[14], n[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(n.begin(), n.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ + GIVEN("N empty hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const size_t N = 16; + + std::vector> e; + for (int i = 0; i < N; ++i) { + e.push_back( + sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210 + 10 * i) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e[0] + .combine_latest( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(200 + 10 * N) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + int i = 0; + std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 200 + 10 * ++i) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("combine_latest never/empty", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + e + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest empty/never", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest empty/return", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest return/empty", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + auto e = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + e + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest never/return", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + o + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("combine_latest return/never", "[combine_latest][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o = sc.make_hot_observable({ + on.on_next(150, 1), + on.on_next(215, 2), + on.on_completed(220) + }); + + auto n = sc.make_hot_observable({ + on.on_next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .combine_latest( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + diff --git a/Rx/v2/test/operators/combine_latest.cpp b/Rx/v2/test/operators/combine_latest.2.cpp similarity index 56% rename from Rx/v2/test/operators/combine_latest.cpp rename to Rx/v2/test/operators/combine_latest.2.cpp index 2916d20..4e26fcc 100644 --- a/Rx/v2/test/operators/combine_latest.cpp +++ b/Rx/v2/test/operators/combine_latest.2.cpp @@ -5,729 +5,6 @@ namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" -SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_completed(230) - }); - - auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(220, 3), - on.on_next(230, 5), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_completed(250) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return o2 - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - o1 - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains combined ints"){ - auto required = rxu::to_vector({ - on.on_next(220, 2 + 3), - on.on_next(225, 4 + 3), - on.on_next(230, 4 + 5), - on.on_next(235, 4 + 6), - on.on_next(240, 4 + 7), - on.on_completed(250) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o1"){ - auto required = rxu::to_vector({ - on.subscribe(200, 230) - }); - auto actual = o1.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o2"){ - auto required = rxu::to_vector({ - on.subscribe(200, 250) - }); - auto actual = o2.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest consecutive", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_completed(230) - }); - - auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_completed(250) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return o2 - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - o1 - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains combined ints"){ - auto required = rxu::to_vector({ - on.on_next(235, 4 + 6), - on.on_next(240, 4 + 7), - on.on_completed(250) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o1"){ - auto required = rxu::to_vector({ - on.subscribe(200, 230) - }); - auto actual = o1.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o2"){ - auto required = rxu::to_vector({ - on.subscribe(200, 250) - }); - auto actual = o2.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest consecutive ends with error left", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - std::runtime_error ex("combine_latest on_error from source"); - - auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_error(230, ex) - }); - - auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_completed(250) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return o2 - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - o1 - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains only an error"){ - auto required = rxu::to_vector({ - on.on_error(230, ex) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o1"){ - auto required = rxu::to_vector({ - on.subscribe(200, 230) - }); - auto actual = o1.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o2"){ - auto required = rxu::to_vector({ - on.subscribe(200, 230) - }); - auto actual = o2.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest consecutive ends with error right", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - std::runtime_error ex("combine_latest on_error from source"); - - auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_completed(250) - }); - - auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_error(245, ex) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return o2 - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - o1 - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains combined ints followed by an error"){ - auto required = rxu::to_vector({ - on.on_next(235, 4 + 6), - on.on_next(240, 4 + 7), - on.on_error(245, ex) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o1"){ - auto required = rxu::to_vector({ - on.subscribe(200, 245) - }); - auto actual = o1.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o2"){ - auto required = rxu::to_vector({ - on.subscribe(200, 245) - }); - auto actual = o2.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest never N", "[combine_latest][join][operators]"){ - GIVEN("N never completed hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - const size_t N = 16; - - std::vector> n; - for (int i = 0; i < N; ++i) { - n.push_back( - sc.make_hot_observable({ - on.on_next(150, 1) - }) - ); - } - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return n[0] - .combine_latest( - [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ - return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; - }, - n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13], n[14], n[15] - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output is empty"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to each observable"){ - - std::for_each(n.begin(), n.end(), [&](rxcpp::test::testable_observable &s){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = s.subscriptions(); - REQUIRE(required == actual); - }); - } - } - } -} - -SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ - GIVEN("N empty hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - const size_t N = 16; - - std::vector> e; - for (int i = 0; i < N; ++i) { - e.push_back( - sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210 + 10 * i) - }) - ); - } - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return e[0] - .combine_latest( - [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ - return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; - }, - e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains only complete message"){ - auto required = rxu::to_vector({ - on.on_completed(200 + 10 * N) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to each observable"){ - - int i = 0; - std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ - auto required = rxu::to_vector({ - on.subscribe(200, 200 + 10 * ++i) - }); - auto actual = s.subscriptions(); - REQUIRE(required == actual); - }); - } - } - } -} - -SCENARIO("combine_latest never/empty", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto n = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return n - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - e - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output is empty"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the n"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = n.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the e"){ - auto required = rxu::to_vector({ - on.subscribe(200, 210) - }); - auto actual = e.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest empty/never", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) - }); - - auto n = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return e - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - n - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output is empty"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the e"){ - auto required = rxu::to_vector({ - on.subscribe(200, 210) - }); - auto actual = e.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the n"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = n.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest empty/return", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) - }); - - auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return e - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - o - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains only complete message"){ - auto required = rxu::to_vector({ - on.on_completed(220) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the e"){ - auto required = rxu::to_vector({ - on.subscribe(200, 210) - }); - auto actual = e.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o"){ - auto required = rxu::to_vector({ - on.subscribe(200, 220) - }); - auto actual = o.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest return/empty", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) - }); - - auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return o - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - e - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output contains only complete message"){ - auto required = rxu::to_vector({ - on.on_completed(220) - }); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o"){ - auto required = rxu::to_vector({ - on.subscribe(200, 220) - }); - auto actual = o.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the e"){ - auto required = rxu::to_vector({ - on.subscribe(200, 210) - }); - auto actual = e.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest never/return", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto n = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return n - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - o - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output is empty"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the n"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = n.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o"){ - auto required = rxu::to_vector({ - on.subscribe(200, 220) - }); - auto actual = o.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - -SCENARIO("combine_latest return/never", "[combine_latest][join][operators]"){ - GIVEN("2 hot observables of ints."){ - auto sc = rxsc::make_test(); - auto w = sc.create_worker(); - const rxsc::test::messages on; - - auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) - }); - - auto n = sc.make_hot_observable({ - on.on_next(150, 1) - }); - - WHEN("each int is combined with the latest from the other source"){ - - auto res = w.start( - [&]() { - return o - .combine_latest( - [](int v2, int v1){ - return v2 + v1; - }, - n - ) - // forget type to workaround lambda deduction bug on msvc 2013 - .as_dynamic(); - } - ); - - THEN("the output is empty"){ - auto required = std::vector::recorded_type>(); - auto actual = res.get_observer().messages(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the n"){ - auto required = rxu::to_vector({ - on.subscribe(200, 1000) - }); - auto actual = n.subscriptions(); - REQUIRE(required == actual); - } - - THEN("there was one subscription and one unsubscription to the o"){ - auto required = rxu::to_vector({ - on.subscribe(200, 220) - }); - auto actual = o.subscriptions(); - REQUIRE(required == actual); - } - } - } -} - SCENARIO("combine_latest return/return", "[combine_latest][join][operators]"){ GIVEN("2 hot observables of ints."){ auto sc = rxsc::make_test(); diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index a34de7f..b5a9cdd 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -36,7 +36,8 @@ set(TEST_SOURCES ${TEST_DIR}/sources/defer.cpp ${TEST_DIR}/sources/interval.cpp ${TEST_DIR}/operators/buffer.cpp - ${TEST_DIR}/operators/combine_latest.cpp + ${TEST_DIR}/operators/combine_latest.1.cpp + ${TEST_DIR}/operators/combine_latest.2.cpp ${TEST_DIR}/operators/concat.cpp ${TEST_DIR}/operators/concat_map.cpp ${TEST_DIR}/operators/distinct_until_changed.cpp -- GitLab From b93318ae594c0ac8c9ebb698cebd0313774d6c20 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 7 Jul 2014 15:04:45 -0700 Subject: [PATCH 378/782] adds subscribe_on --- Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp | 124 ++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 10 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/subscribe_on.cpp | 53 ++++++++ projects/CMake/CMakeLists.txt | 1 + 5 files changed, 189 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp create mode 100644 Rx/v2/test/operators/subscribe_on.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp new file mode 100644 index 0000000..3899b19 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp @@ -0,0 +1,124 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_SUBSCRIBE_ON_HPP) +#define RXCPP_OPERATORS_RX_SUBSCRIBE_ON_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct subscribe_on : public operator_base +{ + typedef typename std::decay::type source_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + struct values + { + values(source_type s, coordination_type sf) + : source(std::move(s)) + , coordination(std::move(sf)) + { + } + source_type source; + coordination_type coordination; + }; + values initial; + + subscribe_on(source_type s, coordination_type sf) + : initial(std::move(s), std::move(sf)) + { + } + + template + void on_subscribe(Subscriber s) const { + + typedef Subscriber output_type; + struct subscribe_on_state_type + : public std::enable_shared_from_this + , public values + { + subscribe_on_state_type(const values& i, coordinator_type coor, const output_type& oarg) + : values(i) + , coordinator(std::move(coor)) + , out(oarg) + { + } + composite_subscription source_lifetime; + coordinator_type coordinator; + output_type out; + }; + + auto coordinator = initial.coordination.create_coordinator(s.get_subscription()); + + auto controller = coordinator.get_worker(); + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new subscribe_on_state_type(initial, std::move(coordinator), std::move(s))); + + state->out.add([=](){ + auto disposer = [=](const rxsc::schedulable&){ + state->source_lifetime.unsubscribe(); + }; + auto selectedDisposer = on_exception( + [&](){return state->coordinator.act(disposer);}, + state->out); + if (selectedDisposer.empty()) { + return; + } + controller.schedule(selectedDisposer.get()); + }); + + auto producer = [=](const rxsc::schedulable&){ + state->source.subscribe(state->source_lifetime, state->out); + }; + + auto selectedProducer = on_exception( + [&](){return state->coordinator.act(producer);}, + state->out); + if (selectedProducer.empty()) { + return; + } + + controller.schedule(selectedProducer.get()); + } +}; + +template +class subscribe_on_factory +{ + typedef typename std::decay::type coordination_type; + + coordination_type coordination; +public: + subscribe_on_factory(coordination_type sf) + : coordination(std::move(sf)) + { + } + template + auto operator()(Observable&& source) + -> observable::type::value_type, subscribe_on::type::value_type, Observable, Coordination>> { + return observable::type::value_type, subscribe_on::type::value_type, Observable, Coordination>>( + subscribe_on::type::value_type, Observable, Coordination>(std::forward(source), coordination)); + } +}; + +} + +template +auto subscribe_on(Coordination sf) + -> detail::subscribe_on_factory { + return detail::subscribe_on_factory(std::move(sf)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 4a016d8..dfc23b2 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -664,6 +664,16 @@ public: return multicast(rxsub::behavior(first, cs)); } + /// subscribe_on -> + /// subscription and unsubscription are queued and delivered using the scheduler from the supplied coordination + /// + template + auto subscribe_on(Coordination cn) const + -> observable::value_type, rxo::detail::subscribe_on> { + return observable::value_type, rxo::detail::subscribe_on>( + rxo::detail::subscribe_on(*this, std::forward(cn))); + } + /// observe_on -> /// all values are queued and delivered using the scheduler from the supplied coordination /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 4ee9865..a8b22e4 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -55,6 +55,7 @@ namespace rxo=operators; #include "operators/rx-skip.hpp" #include "operators/rx-skip_until.hpp" #include "operators/rx-subscribe.hpp" +#include "operators/rx-subscribe_on.hpp" #include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" diff --git a/Rx/v2/test/operators/subscribe_on.cpp b/Rx/v2/test/operators/subscribe_on.cpp new file mode 100644 index 0000000..733aa0e --- /dev/null +++ b/Rx/v2/test/operators/subscribe_on.cpp @@ -0,0 +1,53 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxs=rx::rxs; +namespace rxsc=rx::rxsc; + +#include "catch.hpp" + +static const int static_subscriptions = 100000; + +SCENARIO("for loop subscribes to map with subscribe_on and observe_on", "[hide][for][just][subscribe][subscribe_on][observe_on][long][perf]"){ + const int& subscriptions = static_subscriptions; + GIVEN("a for loop"){ + WHEN("subscribe 100K times"){ + using namespace std::chrono; + typedef steady_clock clock; + + int runs = 10; + + for (;runs > 0; --runs) { + + int c = 0; + int n = 1; + auto start = clock::now(); + for (int i = 0; i < subscriptions; i++) { + std::atomic_bool done(false); + rx::observable<>::just(1) + .map([](int i) { + std::stringstream serializer; + serializer << i; + return serializer.str(); + }) + .map([](const std::string& s) { + int i; + std::stringstream(s) >> i; + return i; + }) + .subscribe_on(rx::observe_on_event_loop()) + .observe_on(rx::observe_on_event_loop()) + .subscribe([&](int i){ + ++c; + }, + [&](){ + done = true; + }); + while(!done); + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "loop subscribe map subscribe_on observe_on : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b5a9cdd..6529de1 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -53,6 +53,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/scan.cpp ${TEST_DIR}/operators/skip.cpp ${TEST_DIR}/operators/skip_until.cpp + ${TEST_DIR}/operators/subscribe_on.cpp ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/take_until.cpp -- GitLab From d23d7108c8b8c12f063b81cae379f6289108802d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 14 Jul 2014 08:55:58 -0700 Subject: [PATCH 379/782] revamp type deferral mechanism for observable --- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 32 ++- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 35 +-- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 22 +- .../src/rxcpp/operators/rx-switch_on_next.hpp | 37 +-- Rx/v2/src/rxcpp/rx-observable.hpp | 251 +++++++++--------- Rx/v2/src/rxcpp/rx-util.hpp | 93 +++++++ 6 files changed, 286 insertions(+), 184 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index 68179be..2afe974 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -13,34 +13,36 @@ namespace operators { namespace detail { -template +template struct concat - : public operator_base::type::value_type::value_type> + : public operator_base::type::value_type> { - typedef concat this_type; + typedef concat this_type; + typedef typename std::decay::type source_value_type; typedef typename std::decay::type source_type; typedef typename std::decay::type coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename source_type::value_type collection_type; + typedef typename source_type::source_operator_type source_operator_type; + typedef source_value_type collection_type; typedef typename collection_type::value_type value_type; struct values { - values(source_type o, coordination_type sf) - : source(std::move(o)) + values(source_operator_type o, coordination_type sf) + : source_operator(std::move(o)) , coordination(std::move(sf)) { } - source_type source; + source_operator_type source_operator; coordination_type coordination; }; values initial; - concat(source_type o, coordination_type sf) - : initial(std::move(o), std::move(sf)) + concat(const source_type& o, coordination_type sf) + : initial(o.source_operator, std::move(sf)) { } @@ -55,7 +57,8 @@ struct concat , public values { concat_state_type(values i, coordinator_type coor, output_type oarg) - : values(std::move(i)) + : values(i) + , source(i.source_operator) , sourceLifetime(composite_subscription::empty()) , collectionLifetime(composite_subscription::empty()) , coordinator(std::move(coor)) @@ -117,6 +120,7 @@ struct concat } selectedSource->subscribe(std::move(selectedSinkInner.get())); } + observable source; composite_subscription sourceLifetime; composite_subscription collectionLifetime; std::deque selectedCollections; @@ -190,10 +194,10 @@ public: } template - auto operator()(Observable&& source) - -> observable::value_type, concat> { - return observable::value_type, concat>( - concat(std::forward(source), coordination)); + auto operator()(Observable source) + -> observable::value_type, concat> { + return observable::value_type, concat>( + concat(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 3b980ad..9faa862 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -13,18 +13,19 @@ namespace operators { namespace detail { -template +template struct merge - : public operator_base::type::value_type::value_type> + : public operator_base::type::value_type> { - static_assert(is_observable::value, "merge requires an observable"); - static_assert(is_observable::value, "merge an observable that contains observables"); + //static_assert(is_observable::value, "merge requires an observable"); + //static_assert(is_observable::value, "merge requires an observable that contains observables"); - typedef merge this_type; + typedef merge this_type; + typedef typename std::decay::type source_value_type; typedef typename std::decay::type source_type; - typedef typename source_type::value_type source_value_type; + typedef typename source_type::source_operator_type source_operator_type; typedef typename source_value_type::value_type value_type; typedef typename std::decay::type coordination_type; @@ -32,18 +33,18 @@ struct merge struct values { - values(source_type o, coordination_type sf) - : source(std::move(o)) + values(source_operator_type o, coordination_type sf) + : source_operator(std::move(o)) , coordination(std::move(sf)) { } - source_type source; + source_operator_type source_operator; coordination_type coordination; }; values initial; - merge(source_type o, coordination_type sf) - : initial(std::move(o), std::move(sf)) + merge(const source_type& o, coordination_type sf) + : initial(o.source_operator, std::move(sf)) { } @@ -58,12 +59,14 @@ struct merge , public values { merge_state_type(values i, coordinator_type coor, output_type oarg) - : values(std::move(i)) + : values(i) + , source(i.source_operator) , pendingCompletions(0) , coordinator(std::move(coor)) , out(std::move(oarg)) { } + observable source; // on_completed on the output must wait until all the // subscriptions have received on_completed int pendingCompletions; @@ -179,10 +182,10 @@ public: } template - auto operator()(Observable&& source) - -> observable::value_type, merge> { - return observable::value_type, merge>( - merge(std::forward(source), coordination)); + auto operator()(Observable source) + -> observable::value_type, merge> { + return observable::value_type, merge>( + merge(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 7ba7015..c70f7bd 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -47,10 +47,10 @@ struct is_result_function_for { static const bool value = !std::is_same::value; }; -template +template struct reduce_traits { - typedef typename std::decay::type source_type; + typedef typename std::decay::type source_type; typedef typename std::decay::type accumulator_type; typedef typename std::decay::type result_selector_type; typedef typename std::decay::type seed_type; @@ -64,11 +64,11 @@ struct reduce_traits typedef typename is_result_function_for::type value_type; }; -template -struct reduce : public operator_base::value_type> +template +struct reduce : public operator_base::value_type> { - typedef reduce this_type; - typedef reduce_traits traits; + typedef reduce this_type; + typedef reduce_traits traits; typedef typename traits::source_type source_type; typedef typename traits::accumulator_type accumulator_type; @@ -106,10 +106,12 @@ struct reduce : public operator_base source; seed_type current; Subscriber out; }; @@ -163,10 +165,10 @@ public: { } template - auto operator()(Observable&& source) - -> observable::type::value_type, Observable, Accumulator, ResultSelector, Seed>> { - return observable::type::value_type, Observable, Accumulator, ResultSelector, Seed>>( - reduce::type::value_type, Observable, Accumulator, ResultSelector, Seed>(std::forward(source), accumulator, result_selector, seed)); + auto operator()(const Observable& source) + -> observable> { + return observable>( + reduce(source.source_operator, accumulator, result_selector, seed)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp index b8c63a4..3403553 100644 --- a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -13,18 +13,21 @@ namespace operators { namespace detail { -template +template struct switch_on_next - : public operator_base::type::value_type::value_type> + : public operator_base::type::value_type> { - static_assert(is_observable::value, "switch_on_next requires an observable"); - static_assert(is_observable::value, "switch_on_next an observable that contains observables"); + //static_assert(is_observable::value, "switch_on_next requires an observable"); + //static_assert(is_observable::value, "switch_on_next requires an observable that contains observables"); - typedef switch_on_next this_type; + typedef switch_on_next this_type; + typedef typename std::decay::type source_value_type; typedef typename std::decay::type source_type; - typedef typename source_type::value_type collection_type; + typedef typename source_type::source_operator_type source_operator_type; + + typedef source_value_type collection_type; typedef typename collection_type::value_type collection_value_type; typedef typename std::decay::type coordination_type; @@ -32,18 +35,18 @@ struct switch_on_next struct values { - values(source_type o, coordination_type sf) - : source(std::move(o)) + values(source_operator_type o, coordination_type sf) + : source_operator(std::move(o)) , coordination(std::move(sf)) { } - source_type source; + source_operator_type source_operator; coordination_type coordination; }; values initial; - switch_on_next(source_type o, coordination_type sf) - : initial(std::move(o), std::move(sf)) + switch_on_next(const source_type& o, coordination_type sf) + : initial(o.source_operator, std::move(sf)) { } @@ -58,12 +61,14 @@ struct switch_on_next , public values { switch_state_type(values i, coordinator_type coor, output_type oarg) - : values(std::move(i)) + : values(i) + , source(i.source_operator) , pendingCompletions(0) , coordinator(std::move(coor)) , out(std::move(oarg)) { } + observable source; // on_completed on the output must wait until all the // subscriptions have received on_completed int pendingCompletions; @@ -188,10 +193,10 @@ public: } template - auto operator()(Observable&& source) - -> observable::value_type, switch_on_next> { - return observable::value_type, switch_on_next>( - switch_on_next(std::forward(source), coordination)); + auto operator()(Observable source) + -> observable::value_type, switch_on_next> { + return observable::value_type, switch_on_next>( + switch_on_next(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index dfc23b2..9ce96b4 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -161,12 +161,67 @@ class observable { static_assert(std::is_same::value, "SourceOperator::value_type must be the same as T in observable"); -protected: typedef observable this_type; + +public: typedef typename std::decay::type source_operator_type; mutable source_operator_type source_operator; +protected: + template + struct resolve_observable; + + template + struct resolve_observable + { + typedef typename SO::type type; + typedef typename type::value_type value_type; + static const bool value = true; + typedef observable observable_type; + template + static observable_type make(const Default&, AN&&... an) { + return observable_type(type(std::forward(an)...)); + } + }; + template + struct resolve_observable + { + static const bool value = false; + typedef Default observable_type; + template + static observable_type make(const observable_type& that, const AN&...) { + return that; + } + }; + template + struct resolve_observable + { + typedef typename SO::type type; + typedef typename type::value_type value_type; + static const bool value = true; + typedef observable observable_type; + template + static observable_type make(AN&&... an) { + return observable_type(type(std::forward(an)...)); + } + }; + template + struct resolve_observable + { + static const bool value = false; + typedef void observable_type; + template + static observable_type make(const AN&...) { + } + }; + template class SO, class... AN> + struct defer_observable + : public resolve_observable> + { + }; + private: + template friend class observable; @@ -341,28 +396,12 @@ public: return lift(rxo::detail::buffer_count(count, skip)); } - template::value> - struct switch_on_next_result; - template - struct switch_on_next_result + struct defer_switch_on_next : public defer_observable< + is_observable, + this_type, + rxo::detail::switch_on_next, value_type, observable, Coordination> { - typedef - observable< - typename this_type::value_type::value_type, - rxo::detail::switch_on_next> - type; - static type make(const this_type* that, Coordination sf) { - return type(rxo::detail::switch_on_next(*that, std::move(sf))); - } - }; - template - struct switch_on_next_result - { - typedef this_type type; - static type make(const this_type* that, Coordination) { - return *that; - } }; /// switch_on_next (AKA Switch) -> @@ -370,8 +409,8 @@ public: /// for each item from this observable subscribe to that observable after unsubscribing from any previous subscription. /// auto switch_on_next() const - -> typename switch_on_next_result::type { - return switch_on_next_result::make(this, identity_current_thread()); + -> typename defer_switch_on_next::observable_type { + return defer_switch_on_next::make(*this, *this, identity_current_thread()); } /// switch_on_next (AKA Switch) -> @@ -379,35 +418,19 @@ public: /// for each item from this observable subscribe to that observable after unsubscribing from any previous subscription. /// template - auto switch_on_next(Coordination&& sf) const - -> typename std::enable_if::value, - observable::value_type, rxo::detail::switch_on_next>>::type { - return observable::value_type, rxo::detail::switch_on_next>( - rxo::detail::switch_on_next(*this, std::forward(sf))); + auto switch_on_next(Coordination cn) const + -> typename std::enable_if< + defer_switch_on_next::value, + typename defer_switch_on_next::observable_type>::type { + return defer_switch_on_next::make(*this, *this, std::move(cn)); } - template::value> - struct merge_result; - template - struct merge_result + struct defer_merge : public defer_observable< + is_observable, + this_type, + rxo::detail::merge, value_type, observable, Coordination> { - typedef - observable< - typename this_type::value_type::value_type, - rxo::detail::merge, Coordination>> - type; - static type make(const this_type* that, Coordination sf) { - return type(rxo::detail::merge, Coordination>(*that, sf)); - } - }; - template - struct merge_result - { - typedef this_type type; - static type make(const this_type* that, Coordination) { - return *that; - } }; /// merge -> @@ -416,8 +439,8 @@ public: /// for each item from all of the nested observables deliver from the new observable that is returned. /// auto merge() const - -> typename merge_result::type { - return merge_result::make(this, identity_current_thread()); + -> typename defer_merge::observable_type { + return defer_merge::make(*this, *this, identity_current_thread()); } /// merge -> @@ -426,11 +449,11 @@ public: /// for each item from all of the nested observables deliver from the new observable that is returned. /// template - auto merge(Coordination&& sf) const - -> typename std::enable_if::value && !is_observable::value, - observable::value_type, rxo::detail::merge>>::type { - return observable::value_type, rxo::detail::merge>( - rxo::detail::merge(*this, std::forward(sf))); + auto merge(Coordination cn) const + -> typename std::enable_if< + defer_merge::value, + typename defer_merge::observable_type>::type { + return defer_merge::make(*this, *this, std::move(cn)); } /// merge -> @@ -480,28 +503,12 @@ public: rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } - template::value> - struct concat_result; - template - struct concat_result + struct defer_concat : public defer_observable< + is_observable, + this_type, + rxo::detail::concat, value_type, observable, Coordination> { - typedef - observable< - typename this_type::value_type::value_type, - rxo::detail::concat, Coordination>> - type; - static type make(const this_type* that, Coordination sf) { - return type(rxo::detail::concat, Coordination>(*that, sf)); - } - }; - template - struct concat_result - { - typedef this_type type; - static type make(const this_type* that, Coordination) { - return *that; - } }; /// concat -> @@ -510,8 +517,8 @@ public: /// for each item from all of the nested observables deliver from the new observable that is returned. /// auto concat() const - -> typename concat_result::type { - return concat_result::make(this, identity_current_thread()); + -> typename defer_concat::observable_type { + return defer_concat::make(*this, *this, identity_current_thread()); } /// concat -> @@ -520,11 +527,11 @@ public: /// for each item from all of the nested observables deliver from the new observable that is returned. /// template - auto concat(Coordination&& sf) const - -> typename std::enable_if::value && !is_observable::value, - observable::value_type, rxo::detail::concat>>::type { - return observable::value_type, rxo::detail::concat>( - rxo::detail::concat(*this, std::forward(sf))); + auto concat(Coordination cn) const + -> typename std::enable_if< + defer_concat::value, + typename defer_concat::observable_type>::type { + return defer_concat::make(*this, *this, std::move(cn)); } /// concat -> @@ -548,6 +555,7 @@ public: -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); } + /// concat_map -> /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. @@ -573,9 +581,11 @@ public: } template - struct delayed_combine_latest + struct defer_combine_latest : public defer_observable< + rxu::all_true::value, !is_observable::value, is_observable::value...>, + this_type, + rxo::detail::combine_latest, Coordination, Selector, ObservableN...> { - typedef observable::value_type, rxo::detail::combine_latest> type; }; /// combine_latest -> @@ -584,10 +594,10 @@ public: /// template auto combine_latest(Selector&& s, ObservableN... on) const - -> typename std::enable_if::value && !is_observable::value && rxu::all_true::value...>::value, - delayed_combine_latest>::type::type { - return observable::value_type, rxo::detail::combine_latest>( - rxo::detail::combine_latest(identity_current_thread(), std::forward(s), std::make_tuple(*this, on...))); + -> typename std::enable_if< + defer_combine_latest::value, + typename defer_combine_latest::observable_type>::type { + return defer_combine_latest::make(*this, identity_current_thread(), std::forward(s), std::make_tuple(*this, on...)); } /// combine_latest -> @@ -596,10 +606,10 @@ public: /// template auto combine_latest(Coordination cn, Selector&& s, ObservableN... on) const - -> typename std::enable_if::value && !is_observable::value && rxu::all_true::value...>::value, - delayed_combine_latest>::type::type { - return observable::value_type, rxo::detail::combine_latest>( - rxo::detail::combine_latest(std::move(cn), std::forward(s), std::make_tuple(*this, on...))); + -> typename std::enable_if< + defer_combine_latest::value, + typename defer_combine_latest::observable_type>::type { + return defer_combine_latest::make(*this, std::move(cn), std::forward(s), std::make_tuple(*this, on...)); } /// combine_latest -> @@ -608,10 +618,10 @@ public: /// template auto combine_latest(ObservableN... on) const - -> typename std::enable_if::value...>::value, - delayed_combine_latest>::type::type { - return observable::value_type, rxo::detail::combine_latest>( - rxo::detail::combine_latest(identity_current_thread(), rxu::pack(), std::make_tuple(*this, on...))); + -> typename std::enable_if< + defer_combine_latest::value, + typename defer_combine_latest::observable_type>::type { + return defer_combine_latest::make(*this, identity_current_thread(), rxu::pack(), std::make_tuple(*this, on...)); } /// combine_latest -> @@ -620,10 +630,10 @@ public: /// template auto combine_latest(Coordination cn, ObservableN... on) const - -> typename std::enable_if::value && rxu::all_true::value...>::value, - delayed_combine_latest>::type::type { - return observable::value_type, rxo::detail::combine_latest>( - rxo::detail::combine_latest(std::move(cn), rxu::pack(), std::make_tuple(*this, on...))); + -> typename std::enable_if< + defer_combine_latest::value, + typename defer_combine_latest::observable_type>::type { + return defer_combine_latest::make(*this, std::move(cn), rxu::pack(), std::make_tuple(*this, on...)); } /// multicast -> @@ -688,50 +698,35 @@ public: /// template auto reduce(Seed seed, Accumulator&& a, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::reduce> { - return observable::value_type, rxo::detail::reduce>( - rxo::detail::reduce(*this, std::forward(a), std::forward(rs), seed)); + -> observable::value_type, rxo::detail::reduce> { + return observable::value_type, rxo::detail::reduce>( + rxo::detail::reduce(source_operator, std::forward(a), std::forward(rs), seed)); } - template::value && - rxo::detail::is_result_function_for::value> - struct specific_reduce_result; - - template - struct specific_reduce_result - { - typedef - observable< - typename rxo::detail::is_result_function_for::type, - rxo::detail::reduce> - type; - static type make(const this_type* that, Seed seed, Accumulator a, ResultSelector rs) { - return type(rxo::detail::reduce(*that, std::move(a), std::move(rs), std::move(seed))); - } - }; template - struct specific_reduce_result + struct defer_reduce : public defer_observable< + rxu::all_true< + rxu::defer_trait::value, + rxu::defer_trait::value>, + void, + rxo::detail::reduce, T, source_operator_type, Accumulator, ResultSelector, Seed> { - typedef void type; - static void make(const this_type* that, Seed, Accumulator, ResultSelector) { - } }; /// sum -> /// for each item from this observable reduce it by adding to the previous values. /// auto sum() const - -> typename specific_reduce_result::seed_type, std::plus, identity_for>::type { - return specific_reduce_result::seed_type, std::plus, identity_for>::make(this, rxo::detail::initialize_seeder().seed(), std::plus(), identity_for()); + -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { + return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, std::plus(), identity_for(), rxo::detail::initialize_seeder().seed()); } /// average -> /// for each item from this observable reduce it by adding to the previous values and then dividing by the number of items at the end. /// auto average() const - -> typename specific_reduce_result::seed_type, rxo::detail::average, rxo::detail::average>::type { - return specific_reduce_result::seed_type, rxo::detail::average, rxo::detail::average>::make(this, rxo::detail::average().seed(), rxo::detail::average(), rxo::detail::average()); + -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { + return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, rxo::detail::average(), rxo::detail::average(), rxo::detail::average().seed()); } /// scan -> diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 713c5a3..6f71c97 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -160,6 +160,99 @@ inline auto pack() return detail::pack(); } +template +struct resolve_type; + +template class Deferred, class... AN> +struct defer_trait +{ + template + struct tag_valid {static const bool valid = true; static const bool value = R;}; + struct tag_not_valid {static const bool valid = false; static const bool value = false;}; + typedef Deferred::type...> resolved_type; + template + static auto check(int) -> tag_valid; + template + static tag_not_valid check(...); + + typedef decltype(check(0)) tag_type; + static const bool valid = tag_type::valid; + static const bool value = tag_type::value; + static const bool not_value = valid && !value; +}; + +template class Deferred, class... AN> +struct defer_type +{ + template + struct tag_valid {typedef R type; static const bool value = true;}; + struct tag_not_valid {typedef void type; static const bool value = false;}; + typedef Deferred::type...> resolved_type; + template + static auto check(int) -> tag_valid; + template + static tag_not_valid check(...); + + typedef decltype(check(0)) tag_type; + typedef typename tag_type::type type; + static const bool value = tag_type::value; +}; + +template class Deferred, class... AN> +struct defer_value_type +{ + template + struct tag_valid {typedef R type; static const bool value = true;}; + struct tag_not_valid {typedef void type; static const bool value = false;}; + typedef Deferred::type...> resolved_type; + template + static auto check(int) -> tag_valid; + template + static tag_not_valid check(...); + + typedef decltype(check(0)) tag_type; + typedef typename tag_type::type type; + static const bool value = tag_type::value; +}; + +template class Deferred, class... AN> +struct defer_seed_type +{ + template + struct tag_valid {typedef R type; static const bool value = true;}; + struct tag_not_valid {typedef void type; static const bool value = false;}; + typedef Deferred::type...> resolved_type; + template + static auto check(int) -> tag_valid; + template + static tag_not_valid check(...); + + typedef decltype(check(0)) tag_type; + typedef typename tag_type::type type; + static const bool value = tag_type::value; +}; + +template +struct resolve_type +{ + typedef D type; +}; +template class Deferred, class... AN> +struct resolve_type> +{ + typedef typename defer_type::type type; +}; +template class Deferred, class... AN> +struct resolve_type> +{ + typedef typename defer_value_type::type type; +}; +template class Deferred, class... AN> +struct resolve_type> +{ + typedef typename defer_seed_type::type type; +}; + template struct println_function { -- GitLab From 46cb2d02762c9cc92c80932c630cfe8ca7b981f1 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 14 Jul 2014 10:21:43 -0700 Subject: [PATCH 380/782] windows does not construct form bool --- Rx/v2/test/operators/concat_map.cpp | 8 ++++---- Rx/v2/test/operators/observe_on.cpp | 4 ++-- Rx/v2/test/operators/subscribe_on.cpp | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 3c4c486..2787089 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -126,8 +126,8 @@ SCENARIO("observe_on concat_map pythagorian ranges", "[hide][range][concat_map][ auto so = rx::observe_on_event_loop(); int c = 0; - std::atomic_bool done(false); - std::atomic_bool disposed(false); + std::atomic_bool done; + std::atomic_bool disposed; std::atomic ct(0); int n = 1; auto start = clock::now(); @@ -194,8 +194,8 @@ SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][s auto so = rx::serialize_event_loop(); int c = 0; - std::atomic_bool done(false); - std::atomic_bool disposed(false); + std::atomic_bool done; + std::atomic_bool disposed; std::atomic ct(0); int n = 1; auto start = clock::now(); diff --git a/Rx/v2/test/operators/observe_on.cpp b/Rx/v2/test/operators/observe_on.cpp index 5b3ac50..fd0a0f8 100644 --- a/Rx/v2/test/operators/observe_on.cpp +++ b/Rx/v2/test/operators/observe_on.cpp @@ -21,8 +21,8 @@ SCENARIO("range observed on current_thread", "[hide][range][observe_on_debug][ob for (int n = 0; n < 10; n++) { - std::atomic_bool disposed(false); - std::atomic_bool done(false); + std::atomic_bool disposed; + std::atomic_bool done; auto c = std::make_shared(0); rx::composite_subscription cs; diff --git a/Rx/v2/test/operators/subscribe_on.cpp b/Rx/v2/test/operators/subscribe_on.cpp index 733aa0e..986a989 100644 --- a/Rx/v2/test/operators/subscribe_on.cpp +++ b/Rx/v2/test/operators/subscribe_on.cpp @@ -22,7 +22,7 @@ SCENARIO("for loop subscribes to map with subscribe_on and observe_on", "[hide][ int n = 1; auto start = clock::now(); for (int i = 0; i < subscriptions; i++) { - std::atomic_bool done(false); + std::atomic_bool done; rx::observable<>::just(1) .map([](int i) { std::stringstream serializer; -- GitLab From af89cd4ae10f10ca7ba4e05e7ef00d649c66dc3b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 14 Jul 2014 10:23:20 -0700 Subject: [PATCH 381/782] windows needs as_dynamic workaround --- Rx/v2/examples/println/main.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Rx/v2/examples/println/main.cpp b/Rx/v2/examples/println/main.cpp index 33598a5..6904d7f 100644 --- a/Rx/v2/examples/println/main.cpp +++ b/Rx/v2/examples/println/main.cpp @@ -5,6 +5,8 @@ namespace rx=rxcpp; namespace rxu=rxcpp::util; +#include + // At this time, RxCpp will fail to compile if the contents // of the std namespace are merged into the global namespace // DO NOT USE: 'using namespace std;' @@ -51,14 +53,14 @@ int main(int argc, char** argv) std::cout << "===== println stream of std::string =====" << std::endl; auto hello_str = [&](){return get_names().map([](std::string n){ return "Hello, " + n + "!"; - });}; + }).as_dynamic();}; hello_str().subscribe(rxu::println(std::cout)); std::cout << "===== println stream of std::tuple =====" << std::endl; auto hello_tpl = [&](){return get_names().map([](std::string n){ return std::make_tuple("Hello, ", n, "! (", n.size(), ")"); - });}; + }).as_dynamic();}; hello_tpl().subscribe(rxu::println(std::cout)); -- GitLab From f9a1b055cd1a55ad686da6a0a6c38d69d45a998e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 14 Jul 2014 10:24:04 -0700 Subject: [PATCH 382/782] more defferrals --- Rx/v2/src/rxcpp/rx-observable.hpp | 158 ++++++++++++++---------- Rx/v2/src/rxcpp/rx-predef.hpp | 3 + Rx/v2/src/rxcpp/sources/rx-interval.hpp | 56 +++++---- 3 files changed, 129 insertions(+), 88 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 9ce96b4..f2301bf 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -151,6 +151,62 @@ observable make_observable_dynamic(Source&& s) { return observable(dynamic_observable(std::forward(s))); } +namespace detail { +template +struct resolve_observable; + +template +struct resolve_observable +{ + typedef typename SO::type type; + typedef typename type::value_type value_type; + static const bool value = true; + typedef observable observable_type; + template + static observable_type make(const Default&, AN&&... an) { + return observable_type(type(std::forward(an)...)); + } +}; +template +struct resolve_observable +{ + static const bool value = false; + typedef Default observable_type; + template + static observable_type make(const observable_type& that, const AN&...) { + return that; + } +}; +template +struct resolve_observable +{ + typedef typename SO::type type; + typedef typename type::value_type value_type; + static const bool value = true; + typedef observable observable_type; + template + static observable_type make(AN&&... an) { + return observable_type(type(std::forward(an)...)); + } +}; +template +struct resolve_observable +{ + static const bool value = false; + typedef void observable_type; + template + static observable_type make(const AN&...) { + } +}; + +} + +template class SO, class... AN> +struct defer_observable + : public detail::resolve_observable> +{ +}; + template<> class observable; @@ -167,59 +223,6 @@ public: typedef typename std::decay::type source_operator_type; mutable source_operator_type source_operator; -protected: - template - struct resolve_observable; - - template - struct resolve_observable - { - typedef typename SO::type type; - typedef typename type::value_type value_type; - static const bool value = true; - typedef observable observable_type; - template - static observable_type make(const Default&, AN&&... an) { - return observable_type(type(std::forward(an)...)); - } - }; - template - struct resolve_observable - { - static const bool value = false; - typedef Default observable_type; - template - static observable_type make(const observable_type& that, const AN&...) { - return that; - } - }; - template - struct resolve_observable - { - typedef typename SO::type type; - typedef typename type::value_type value_type; - static const bool value = true; - typedef observable observable_type; - template - static observable_type make(AN&&... an) { - return observable_type(type(std::forward(an)...)); - } - }; - template - struct resolve_observable - { - static const bool value = false; - typedef void observable_type; - template - static observable_type make(const AN&...) { - } - }; - template class SO, class... AN> - struct defer_observable - : public resolve_observable> - { - }; - private: template @@ -456,6 +459,16 @@ public: return defer_merge::make(*this, *this, std::move(cn)); } + template + struct defer_merge_from : public defer_observable< + rxu::all_true< + is_coordination::value, + is_observable::value>, + this_type, + rxo::detail::merge, observable, observable>, Coordination> + { + }; + /// merge -> /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe. @@ -463,8 +476,10 @@ public: /// template auto merge(Value0 v0, ValueN... vn) const - -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { - return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(); + -> typename std::enable_if< + defer_merge_from::value, + typename defer_merge_from::observable_type>::type { + return defer_merge_from::make(*this, rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...), identity_current_thread()); } /// merge -> @@ -473,12 +488,13 @@ public: /// for each item from all of the nested observables deliver from the new observable that is returned. /// template - auto merge(Coordination&& sf, Value0 v0, ValueN... vn) const - -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).merge(std::forward(sf)); + auto merge(Coordination cn, Value0 v0, ValueN... vn) const + -> typename std::enable_if< + defer_merge_from::value, + typename defer_merge_from::observable_type>::type { + return defer_merge_from::make(*this, rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...), std::move(cn)); } - /// flat_map (AKA SelectMany) -> /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable use the CollectionSelector to select an observable and subscribe to that observable. @@ -534,6 +550,16 @@ public: return defer_concat::make(*this, *this, std::move(cn)); } + template + struct defer_concat_from : public defer_observable< + rxu::all_true< + is_coordination::value, + is_observable::value>, + this_type, + rxo::detail::concat, observable, observable>, Coordination> + { + }; + /// concat -> /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from this observable subscribe to one at a time. in the order received. @@ -541,8 +567,10 @@ public: /// template auto concat(Value0 v0, ValueN... vn) const - -> typename std::enable_if::value, is_observable::value...>::value, observable>::type { - return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(); + -> typename std::enable_if< + defer_concat_from::value, + typename defer_concat_from::observable_type>::type { + return defer_concat_from::make(*this, rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...), identity_current_thread()); } /// concat -> @@ -551,9 +579,11 @@ public: /// for each item from all of the nested observables deliver from the new observable that is returned. /// template - auto concat(Coordination&& sf, Value0 v0, ValueN... vn) const - -> typename std::enable_if::value, is_observable::value...>::value && !is_observable::value, observable>::type { - return rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...).concat(std::forward(sf)); + auto concat(Coordination cn, Value0 v0, ValueN... vn) const + -> typename std::enable_if< + defer_concat_from::value, + typename defer_concat_from::observable_type>::type { + return defer_concat_from::make(*this, rxs::from(this->as_dynamic(), v0.as_dynamic(), vn.as_dynamic()...), std::move(cn)); } /// concat_map -> diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 482b89e..3a36afa 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -131,6 +131,9 @@ class observable; template observable make_observable_dynamic(Source&&); +template class SO, class... AN> +struct defer_observable; + struct tag_observable {}; template struct observable_base { diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 4860acc..0bb62f5 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -68,40 +68,48 @@ struct interval : public source_base } }; -template -struct delay_resolution +template +struct defer_interval : public defer_observable< + rxu::all_true< + std::is_convertible::value, + is_coordination::value>, + void, + interval, Coordination> { - typedef observable> type; }; } + template -static auto interval(TimePoint when) - -> typename detail::delay_resolution::type { - auto cn = identity_current_thread(); - return observable>( - rxs::detail::interval(when, rxsc::scheduler::clock_type::duration::max(), cn)); - static_assert(std::is_convertible::value, "TimePoint must be convertible to rxsc::scheduler::clock_type::time_point"); +auto interval(TimePoint when) + -> typename std::enable_if< + detail::defer_interval::value, + typename detail::defer_interval::observable_type>::type { + return detail::defer_interval::make(when, rxsc::scheduler::clock_type::duration::max(), identity_current_thread()); } + template -static auto interval(rxsc::scheduler::clock_type::time_point when, Coordination cn) - -> typename std::enable_if::value, - observable>>::type { - return observable>( - rxs::detail::interval(when, rxsc::scheduler::clock_type::duration::max(), std::move(cn))); +auto interval(rxsc::scheduler::clock_type::time_point when, Coordination cn) + -> typename std::enable_if< + detail::defer_interval::value, + typename detail::defer_interval::observable_type>::type { + return detail::defer_interval::make(when, rxsc::scheduler::clock_type::duration::max(), std::move(cn)); } -template -static auto interval(rxsc::scheduler::clock_type::time_point initial, Duration period) - -> typename std::enable_if::value, - typename detail::delay_resolution>::type::type { - return observable>( - rxs::detail::interval(initial, period, identity_current_thread())); + +template +auto interval(TimePoint when, rxsc::scheduler::clock_type::duration period) + -> typename std::enable_if< + detail::defer_interval::value, + typename detail::defer_interval::observable_type>::type { + return detail::defer_interval::make(when, period, identity_current_thread()); } + template -static auto interval(rxsc::scheduler::clock_type::time_point initial, rxsc::scheduler::clock_type::duration period, Coordination cn) - -> observable> { - return observable>( - rxs::detail::interval(initial, period, std::move(cn))); +auto interval(rxsc::scheduler::clock_type::time_point when, rxsc::scheduler::clock_type::duration period, Coordination cn) + -> typename std::enable_if< + detail::defer_interval::value, + typename detail::defer_interval::observable_type>::type { + return detail::defer_interval::make(when, period, std::move(cn)); } } -- GitLab From 638ec22f5a6073f15829b542577afc79e163d7cf Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 15 Jul 2014 22:02:19 -0700 Subject: [PATCH 383/782] fixes some compilation issues adds a start_with ish thang --- Rx/v2/src/rxcpp/rx-observable.hpp | 37 +++++++++++++++++++++++--- Rx/v2/src/rxcpp/rx-util.hpp | 8 ++++++ Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 4 +-- 3 files changed, 44 insertions(+), 5 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index f2301bf..70c16a9 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -612,7 +612,7 @@ public: template struct defer_combine_latest : public defer_observable< - rxu::all_true::value, !is_observable::value, is_observable::value...>, + rxu::all_true::value, !is_coordination::value, !is_observable::value, is_observable::value...>, this_type, rxo::detail::combine_latest, Coordination, Selector, ObservableN...> { @@ -747,8 +747,8 @@ public: /// for each item from this observable reduce it by adding to the previous values. /// auto sum() const - -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { - return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, std::plus(), identity_for(), rxo::detail::initialize_seeder().seed()); + -> typename defer_reduce, rxu::plus, rxu::defer_type>::observable_type { + return defer_reduce, rxu::plus, rxu::defer_type>::make(source_operator, rxu::plus(), identity_for(), rxo::detail::initialize_seeder().seed()); } /// average -> @@ -888,6 +888,32 @@ public: return observable>( rxo::detail::repeat(*this, t)); } +#if 0 + +// causes infinite compile time recursion + + template + struct defer_start_with_from : public defer_observable< + rxu::all_true< + is_coordination::value, + std::is_convertible::value>, + this_type, + rxo::detail::concat, observable, observable>, Coordination> + { + }; + + /// start_with -> + /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// + /// + template + auto start_with(Value0 v0, ValueN... vn) const + -> typename std::enable_if< + defer_start_with_from::value, + typename defer_start_with_from::observable_type>::type { + return defer_start_with_from::make(*this, rxs::from(rxs::from(value_type(v0), value_type(vn)...).as_dynamic(), this->as_dynamic()), identity_immediate()); + } +#endif }; template @@ -1017,6 +1043,11 @@ public: -> decltype(rxs::error(std::forward(e), std::move(cn))) { return rxs::error(std::forward(e), std::move(cn)); } + template + static auto start_with(Observable o, Value0 v0, ValueN... vn) + -> decltype(rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o)) { + return rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o); + } }; diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 6f71c97..06da93e 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -253,6 +253,14 @@ struct resolve_type> typedef typename defer_seed_type::type type; }; +struct plus +{ + template + auto operator()(LHS&& lhs, RHS&& rhs) const + -> decltype(std::forward(lhs) + std::forward(rhs)) + { return std::forward(lhs) + std::forward(rhs); } +}; + template struct println_function { diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index 23107da..4c1fbef 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -159,14 +159,14 @@ auto from(Coordination cn) template auto from(Value0 v0, ValueN... vn) -> typename std::enable_if::value, - decltype(iterate(std::array(), identity_immediate()))>::type { + decltype(iterate(std::array{v0, vn...}, identity_immediate()))>::type { std::array c = {v0, vn...}; return iterate(std::move(c), identity_immediate()); } template auto from(Coordination cn, Value0 v0, ValueN... vn) -> typename std::enable_if::value, - decltype(iterate(std::array(), std::move(cn)))>::type { + decltype(iterate(std::array{v0, vn...}, std::move(cn)))>::type { std::array c = {v0, vn...}; return iterate(std::move(c), std::move(cn)); } -- GitLab From ecf04618ca074a8184b3c99a95647234c2905556 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 16 Jul 2014 00:41:26 -0700 Subject: [PATCH 384/782] fix bugs in all the operators that use lift --- Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp | 9 ++- .../operators/rx-distinct_until_changed.hpp | 7 +-- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 11 ++-- Rx/v2/src/rxcpp/operators/rx-map.hpp | 7 +-- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 6 +- Rx/v2/src/rxcpp/rx-observer.hpp | 8 +++ Rx/v2/src/rxcpp/rx-subscriber.hpp | 60 +++++++++++++++++++ 7 files changed, 86 insertions(+), 22 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp index 5bd0ee4..1a9029a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp @@ -37,16 +37,15 @@ struct buffer_count } template - struct buffer_count_observer : public buffer_count_values, public observer_base> + struct buffer_count_observer : public buffer_count_values { typedef buffer_count_observer this_type; - typedef observer_base> base_type; - typedef typename base_type::value_type value_type; + typedef std::vector value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; dest_type dest; mutable int cursor; - mutable std::deque> chunks; + mutable std::deque chunks; buffer_count_observer(dest_type d, buffer_count_values v) : buffer_count_values(v) @@ -85,7 +84,7 @@ struct buffer_count dest.on_completed(); } - static subscriber make(dest_type d, buffer_count_values v) { + static subscriber> make(dest_type d, buffer_count_values v) { auto cs = d.get_subscription(); return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v))); } diff --git a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp index 52954f5..a5ad360 100644 --- a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp @@ -19,11 +19,10 @@ struct distinct_until_changed typedef typename std::decay::type source_value_type; template - struct distinct_until_changed_observer : public observer_base + struct distinct_until_changed_observer { typedef distinct_until_changed_observer this_type; - typedef observer_base base_type; - typedef typename base_type::value_type value_type; + typedef source_value_type value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; dest_type dest; @@ -46,7 +45,7 @@ struct distinct_until_changed dest.on_completed(); } - static subscriber make(dest_type d) { + static subscriber> make(dest_type d) { return make_subscriber(d, this_type(d)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index ae768c7..6dc727c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -26,19 +26,18 @@ struct filter } template - struct filter_observer : public observer_base + struct filter_observer { typedef filter_observer this_type; - typedef observer_base base_type; - typedef typename base_type::value_type value_type; + typedef source_value_type value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; dest_type dest; test_type test; filter_observer(dest_type d, test_type t) - : dest(d) - , test(t) + : dest(std::move(d)) + , test(std::move(t)) { } void on_next(source_value_type v) const { @@ -59,7 +58,7 @@ struct filter dest.on_completed(); } - static subscriber make(dest_type d, test_type t) { + static subscriber> make(dest_type d, test_type t) { return make_subscriber(d, this_type(d, std::move(t))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 6719f1c..19e31d2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -27,11 +27,10 @@ struct map } template - struct map_observer : public observer_base + struct map_observer { typedef map_observer this_type; - typedef observer_base base_type; - typedef typename base_type::value_type value_type; + typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; dest_type dest; @@ -59,7 +58,7 @@ struct map dest.on_completed(); } - static subscriber make(dest_type d, select_type s) { + static subscriber> make(dest_type d, select_type s) { auto cs = d.get_subscription(); return make_subscriber(std::move(cs), this_type(std::move(d), std::move(s))); } diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 001a4e2..8e6c18d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -29,11 +29,11 @@ struct observe_on } template - struct observe_on_observer : public observer_base + struct observe_on_observer { typedef observe_on_observer this_type; typedef observer_base base_type; - typedef typename base_type::value_type value_type; + typedef source_value_type value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; @@ -159,7 +159,7 @@ struct observe_on state->ensure_processing(guard); } - static subscriber make(dest_type d, coordination_type cn, composite_subscription cs = composite_subscription()) { + static subscriber> make(dest_type d, coordination_type cn, composite_subscription cs = composite_subscription()) { auto coor = cn.create_coordinator(d.get_subscription()); d.add(cs); diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 12d151d..42741fc 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -291,6 +291,14 @@ auto make_observer(observer o) -> observer { return observer(std::move(o)); } +template +auto make_observer(Observer ob) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_observer::value, + observer>::type { + return observer(std::move(ob)); +} template auto make_observer(OnNext on) -> typename std::enable_if< diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 90cc7d4..bd09873 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -145,6 +145,16 @@ auto make_subscriber( // observer // +template +auto make_subscriber() + -> typename std::enable_if< + detail::is_on_next_of>::value, + subscriber>>>>::type { + return subscriber>>>(composite_subscription(), + observer>>( + static_observer>(detail::OnNextEmpty()))); +} + template auto make_subscriber( const observer& o) @@ -158,6 +168,16 @@ auto make_subscriber(const Observer& o) subscriber>::type { return subscriber(composite_subscription(), o); } +template +auto make_subscriber(const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + return subscriber>(composite_subscription(), o); +} template auto make_subscriber(const OnNext& on) -> typename std::enable_if< @@ -201,6 +221,15 @@ auto make_subscriber(const OnNext& on, const OnError& oe, const OnCompleted& oc) // explicit lifetime // + +template +auto make_subscriber(const composite_subscription& cs) + -> subscriber>>> { + return subscriber>>>(cs, + observer>>( + static_observer>(detail::OnNextEmpty()))); +} + template auto make_subscriber(const composite_subscription& cs, const observer& o) @@ -214,6 +243,16 @@ auto make_subscriber(const composite_subscription& cs, const Observer& o) subscriber>::type { return subscriber(cs, o); } +template +auto make_subscriber(const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + return subscriber>(cs, o); +} template auto make_subscriber(const composite_subscription& cs, const OnNext& on) -> typename std::enable_if< @@ -257,6 +296,7 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O // chain defaults from subscriber // + template auto make_subscriber(const subscriber& scbr, const observer& o) @@ -270,6 +310,16 @@ auto make_subscriber(const subscriber& scbr, const Observ subscriber>::type { return subscriber(scbr.get_subscription(), o); } +template +auto make_subscriber(const subscriber& scbr, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + return subscriber>(scbr.get_subscription(), o); +} template auto make_subscriber(const subscriber& scbr, const OnNext& on) -> typename std::enable_if< @@ -324,6 +374,16 @@ auto make_subscriber(const subscriber& scbr, const compos subscriber>::type { return subscriber(cs, o); } +template +auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + return subscriber>(cs, o); +} template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on) -> typename std::enable_if< -- GitLab From 71d24ac3fef3a813479c9da1fa0e4a707114697b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 16 Jul 2014 00:41:35 -0700 Subject: [PATCH 385/782] add finally --- Rx/v2/src/rxcpp/operators/rx-finally.hpp | 96 ++++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 14 +++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + 3 files changed, 108 insertions(+), 3 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-finally.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-finally.hpp b/Rx/v2/src/rxcpp/operators/rx-finally.hpp new file mode 100644 index 0000000..a5d7ef9 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-finally.hpp @@ -0,0 +1,96 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_FINALLY_HPP) +#define RXCPP_OPERATORS_RX_FINALLY_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct finally +{ + typedef typename std::decay::type source_value_type; + typedef typename std::decay::type last_call_type; + last_call_type last_call; + + finally(last_call_type lc) + : last_call(std::move(lc)) + { + } + + template + struct finally_observer + { + typedef finally_observer this_type; + typedef source_value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + + finally_observer(dest_type d) + : dest(std::move(d)) + { + } + void on_next(source_value_type v) const { + dest.on_next(v); + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_completed(); + } + + static subscriber> make(dest_type d, const last_call_type& lc) { + auto dl = d.get_subscription(); + composite_subscription cs; + dl.add(cs); + cs.add([=](){ + dl.unsubscribe(); + lc(); + }); + return make_subscriber(cs, this_type(d)); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(finally_observer::make(std::move(dest), last_call)) { + return finally_observer::make(std::move(dest), last_call); + } +}; + +template +class finally_factory +{ + typedef typename std::decay::type last_call_type; + last_call_type last_call; +public: + finally_factory(last_call_type lc) : last_call(std::move(lc)) {} + template + auto operator()(Observable&& source) + -> decltype(source.lift(filter::type::value_type, last_call_type>(last_call))) { + return source.lift(filter::type::value_type, last_call_type>(last_call)); + } +}; + +} + +template +auto finally(LastCall lc) + -> detail::finally_factory { + return detail::finally_factory(std::move(lc)); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 70c16a9..81edaae 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -351,10 +351,10 @@ public: /// the on_next, on_error, on_completed methods can be supplied instead of an observer /// if a subscription or subscriber is not provided then a new subscription will be created. /// - template - auto subscribe(Arg0&& a0, ArgN&&... an) const + template + auto subscribe(ArgN&&... an) const -> composite_subscription { - return detail_subscribe(make_subscriber(std::forward(a0), std::forward(an)...)); + return detail_subscribe(make_subscriber(std::forward(an)...)); } /// filter (AKA Where) -> @@ -366,6 +366,14 @@ public: return lift(rxo::detail::filter(std::move(p))); } + /// finally () -> + /// + template + auto finally(LastCall lc) const + -> decltype(EXPLICIT_THIS lift(rxo::detail::finally(std::move(lc)))) { + return lift(rxo::detail::finally(std::move(lc))); + } + /// map (AKA Select) -> /// for each item from this observable use Selector to produce an item to emit from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index a8b22e4..ef23812 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -41,6 +41,7 @@ namespace rxo=operators; #include "operators/rx-connect_forever.hpp" #include "operators/rx-distinct_until_changed.hpp" #include "operators/rx-filter.hpp" +#include "operators/rx-finally.hpp" #include "operators/rx-flat_map.hpp" #include "operators/rx-lift.hpp" #include "operators/rx-map.hpp" -- GitLab From 7c415c1da911d83e790a1fbaea2d2e4050cbb5b6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 16 Jul 2014 12:03:41 -0700 Subject: [PATCH 386/782] try to find a solution that works on all compilers --- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index 4c1fbef..19aa84e 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -159,14 +159,14 @@ auto from(Coordination cn) template auto from(Value0 v0, ValueN... vn) -> typename std::enable_if::value, - decltype(iterate(std::array{v0, vn...}, identity_immediate()))>::type { + decltype(iterate(*(std::array*)nullptr, identity_immediate()))>::type { std::array c = {v0, vn...}; return iterate(std::move(c), identity_immediate()); } template auto from(Coordination cn, Value0 v0, ValueN... vn) -> typename std::enable_if::value, - decltype(iterate(std::array{v0, vn...}, std::move(cn)))>::type { + decltype(iterate(*(std::array*)nullptr, std::move(cn)))>::type { std::array c = {v0, vn...}; return iterate(std::move(c), std::move(cn)); } -- GitLab From 2766c4688cc7bebabb584d94b7fc418b82a83136 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 28 Jul 2014 16:47:34 +0400 Subject: [PATCH 387/782] Add window operator --- Rx/v2/src/rxcpp/operators/rx-window.hpp | 145 ++++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 16 +++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + projects/CMake/CMakeLists.txt | 1 + 4 files changed, 163 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-window.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-window.hpp b/Rx/v2/src/rxcpp/operators/rx-window.hpp new file mode 100644 index 0000000..d87285d --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-window.hpp @@ -0,0 +1,145 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_WINDOW_HPP) +#define RXCPP_OPERATORS_RX_WINDOW_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct window +{ + typedef typename std::decay::type source_value_type; + struct window_values + { + window_values(int c, int s) + : count(c) + , skip(s) + { + } + int count; + int skip; + }; + + window_values initial; + + window(int count, int skip) + : initial(count, skip) + { + } + + struct window_observable : public sources::source_base + { + mutable rxcpp::subjects::subject subj; + + window_observable(rxcpp::subjects::subject s) + : subj(std::move(s)) + { + } + + template + void on_subscribe(Subscriber o) const { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + subj.get_observable().subscribe(o); + } + }; + + template + struct window_observer : public window_values, public observer_base> + { + typedef window_observer this_type; + typedef observer_base> base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + dest_type dest; + mutable int cursor; + mutable std::deque> subj; + + window_observer(dest_type d, window_values v) + : window_values(v) + , dest(std::move(d)) + , cursor(0) + { + subj.push_back(rxcpp::subjects::subject()); + dest.on_next(observable(window_observable(subj[0]))); + } + void on_next(T v) const { + for (auto s : subj) { + s.get_subscriber().on_next(v); + } + + int c = cursor - this->count + 1; + if (c >= 0 && c % this->skip == 0) { + subj[0].get_subscriber().on_completed(); + subj.pop_front(); + } + + if (++cursor % this->skip == 0) { + subj.push_back(rxcpp::subjects::subject()); + dest.on_next(observable(window_observable(subj[subj.size() - 1]))); + } + } + + void on_error(std::exception_ptr e) const { + for (auto s : subj) { + s.get_subscriber().on_error(e); + } + dest.on_error(e); + } + + void on_completed() const { + for (auto s : subj) { + s.get_subscriber().on_completed(); + } + dest.on_completed(); + } + + static subscriber make(dest_type d, window_values v) { + auto cs = d.get_subscription(); + return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(window_observer::make(std::move(dest), initial)) { + return window_observer::make(std::move(dest), initial); + } +}; + +class window_factory +{ + int count; + int skip; +public: + window_factory(int c, int s) : count(c), skip(s) {} + template + auto operator()(Observable&& source) + -> decltype(source.lift(window::type::value_type>(count, skip))) { + return source.lift(window::type::value_type>(count, skip)); + } +}; + +} + +inline auto window(int count) + -> detail::window_factory { + return detail::window_factory(count, count); +} +inline auto window(int count, int skip) + -> detail::window_factory { + return detail::window_factory(count, skip); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 81edaae..72a8bb7 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -391,6 +391,22 @@ public: return lift(rxo::detail::distinct_until_changed()); } + /// window -> + /// produce observables containing count items emitted by this observable + /// + auto window(int count) const + -> decltype(EXPLICIT_THIS lift(rxo::detail::window(count, count))) { + return lift(rxo::detail::window(count, count)); + } + + /// window -> + /// produce observables containing count items emitted by this observable + /// + auto window(int count, int skip) const + -> decltype(EXPLICIT_THIS lift(rxo::detail::window(count, skip))) { + return lift(rxo::detail::window(count, skip)); + } + /// buffer -> /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index ef23812..8ec9e74 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -60,5 +60,6 @@ namespace rxo=operators; #include "operators/rx-switch_on_next.hpp" #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" +#include "operators/rx-window.hpp" #endif diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 6529de1..9e34654 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -57,6 +57,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/switch_on_next.cpp ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/take_until.cpp + ${TEST_DIR}/operators/window.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) -- GitLab From b4b4c4766a66d2b70448df870ba7480257df061a Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 28 Jul 2014 16:47:53 +0400 Subject: [PATCH 388/782] Add tests for window operator --- Rx/v2/test/operators/window.cpp | 307 ++++++++++++++++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 Rx/v2/test/operators/window.cpp diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp new file mode 100644 index 0000000..ed98030 --- /dev/null +++ b/Rx/v2/test/operators/window.cpp @@ -0,0 +1,307 @@ +#include "rxcpp/rx.hpp" +namespace rx = rxcpp; +namespace rxu = rxcpp::util; +namespace rxs = rxcpp::sources; +namespace rxsc = rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +namespace rxt = rxcpp::test; + +#include "catch.hpp" + +SCENARIO("window count, basic", "[window][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + auto res = w.start( + [&]() { + return xs + .window(3, 2) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window count, inner timings", "[window][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + auto res = rxcpp::observable>(); + auto windows = std::vector>(); + auto observers = std::vector>(); + + w.schedule_absolute( + rxsc::test::created_time, + [&](const rxsc::schedulable& scbl) { + res = xs + .window(3, 2); + } + ); + + w.schedule_absolute( + rxsc::test::subscribed_time, + [&](const rxsc::schedulable& scbl) { + res.subscribe( + // on_next + [&](rx::observable window) { + auto result = w.make_subscriber(); + windows.push_back(window); + observers.push_back(result.get_observer()); + window.subscribe(result); + } + ); + } + ); + + w.start(); + + THEN("the output contains 5 windows"){ + REQUIRE(5 == observers.size()); + } + + THEN("the 1st output window contains ints"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_completed(280) + }); + auto actual = observers[0].messages(); + REQUIRE(required == actual); + } + + THEN("the 2nd output window contains ints"){ + auto required = rxu::to_vector({ + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_completed(350) + }); + auto actual = observers[1].messages(); + REQUIRE(required == actual); + } + + THEN("the 3rd output window contains ints"){ + auto required = rxu::to_vector({ + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_completed(420) + }); + auto actual = observers[2].messages(); + REQUIRE(required == actual); + } + + THEN("the 4th output window contains ints"){ + auto required = rxu::to_vector({ + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + auto actual = observers[3].messages(); + REQUIRE(required == actual); + } + + THEN("the 5th output window contains only complete message"){ + auto required = rxu::to_vector({ + on.on_completed(600) + }); + auto actual = observers[4].messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window count, error", "[window][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + auto res = w.start( + [&]() { + return xs + .window(3, 2) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 370 + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(350, 6) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 370) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window count, basic", "[window][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + std::runtime_error ex("window on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(100, 1), + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_error(600, ex) + }); + + WHEN("group each int with the next 2 ints"){ + auto res = w.start( + [&]() { + return xs + .window(3, 2) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + on.on_next(210, 2), + on.on_next(240, 3), + on.on_next(280, 4), + on.on_next(280, 4), + on.on_next(320, 5), + on.on_next(350, 6), + on.on_next(350, 6), + on.on_next(380, 7), + on.on_next(420, 8), + on.on_next(420, 8), + on.on_next(470, 9), + on.on_error(600, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From eb2af54bc2c0c2df479cee34ab21e1fd44219c11 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 29 Jul 2014 11:51:46 +0400 Subject: [PATCH 389/782] Change text on window tests --- Rx/v2/test/operators/window.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index ed98030..af54699 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -40,7 +40,7 @@ SCENARIO("window count, basic", "[window][operators]"){ } ); - THEN("the output contains groups of ints"){ + THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ on.on_next(210, 2), on.on_next(240, 3), @@ -59,7 +59,7 @@ SCENARIO("window count, basic", "[window][operators]"){ REQUIRE(required == actual); } - THEN("there was one subscription and one unsubscription to the xs"){ + THEN("there was one subscription and one unsubscription to the observable"){ auto required = rxu::to_vector({ o_on.subscribe(200, 600) }); @@ -167,7 +167,7 @@ SCENARIO("window count, inner timings", "[window][operators]"){ REQUIRE(required == actual); } - THEN("the 5th output window contains only complete message"){ + THEN("the 5th output window only contains complete message"){ auto required = rxu::to_vector({ on.on_completed(600) }); @@ -186,7 +186,7 @@ SCENARIO("window count, inner timings", "[window][operators]"){ } } -SCENARIO("window count, error", "[window][operators]"){ +SCENARIO("window count, dispose", "[window][operators]"){ GIVEN("1 hot observable of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -218,7 +218,7 @@ SCENARIO("window count, error", "[window][operators]"){ 370 ); - THEN("the output contains groups of ints"){ + THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ on.on_next(210, 2), on.on_next(240, 3), @@ -232,7 +232,7 @@ SCENARIO("window count, error", "[window][operators]"){ REQUIRE(required == actual); } - THEN("there was one subscription and one unsubscription to the xs"){ + THEN("there was one subscription and one unsubscription to the observable"){ auto required = rxu::to_vector({ o_on.subscribe(200, 370) }); @@ -243,7 +243,7 @@ SCENARIO("window count, error", "[window][operators]"){ } } -SCENARIO("window count, basic", "[window][operators]"){ +SCENARIO("window count, error", "[window][operators]"){ GIVEN("1 hot observable of ints."){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); @@ -276,7 +276,7 @@ SCENARIO("window count, basic", "[window][operators]"){ } ); - THEN("the output contains groups of ints"){ + THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ on.on_next(210, 2), on.on_next(240, 3), @@ -295,7 +295,7 @@ SCENARIO("window count, basic", "[window][operators]"){ REQUIRE(required == actual); } - THEN("there was one subscription and one unsubscription to the xs"){ + THEN("there was one subscription and one unsubscription to the observable"){ auto required = rxu::to_vector({ o_on.subscribe(200, 600) }); -- GitLab From a5f53c4efff956d9f3c7232b23711dddc7f44612 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 22 Jul 2014 16:27:23 -0700 Subject: [PATCH 390/782] add tracing hooks --- Rx/v2/examples/pythagorian/main.cpp | 103 +++++++++++++++++++++++++- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 5 +- Rx/v2/src/rxcpp/rx-includes.hpp | 2 + Rx/v2/src/rxcpp/rx-observable.hpp | 4 + Rx/v2/src/rxcpp/rx-predef.hpp | 11 +++ Rx/v2/src/rxcpp/rx-scheduler.hpp | 25 ++++++- Rx/v2/src/rxcpp/rx-subscriber.hpp | 62 +++++++++++++--- Rx/v2/src/rxcpp/rx-subscription.hpp | 23 +++++- Rx/v2/src/rxcpp/rx-trace.hpp | 78 +++++++++++++++++++ 9 files changed, 293 insertions(+), 20 deletions(-) create mode 100644 Rx/v2/src/rxcpp/rx-trace.hpp diff --git a/Rx/v2/examples/pythagorian/main.cpp b/Rx/v2/examples/pythagorian/main.cpp index 2fd1fdf..379b1e2 100644 --- a/Rx/v2/examples/pythagorian/main.cpp +++ b/Rx/v2/examples/pythagorian/main.cpp @@ -1,3 +1,99 @@ + +#include "rxcpp/rx-trace.hpp" + +struct trace_calls : rxcpp::trace_noop +{ + trace_calls() + : onnexts(0) + , onerrors(0) + , oncompleteds(0) + , subscribes(0) + , lifts(0) + , unsubscribes(0) + , adds(0) + , removes(0) + , actions(0) + , recurses(0) + , schedules(0) + , schedulewhens(0) + {} + + template + inline void schedule_return(const Worker&) { + schedules++; + } + + template + inline void schedule_when_return(const Worker&) { + schedulewhens++; + } + + template + inline void action_return(const Schedulable&) { + actions++; + } + + template + inline void action_recurse(const Schedulable&) { + recurses++; + } + + template + inline void subscribe_return(const Observable& o) { + subscribes++; + } + + template + inline void lift_return(const OperatorSource&, const OperatorChain&) { + lifts++; + } + + template + inline void unsubscribe_return(const SubscriptionState&) { + unsubscribes++; + } + + template + inline void subscription_add_return(const SubscriptionState&) { + adds++; + } + + template + inline void subscription_remove_return(const SubscriptionState&) { + removes++; + } + + template + inline void on_next_return(const Observer&) { + onnexts++; + } + + template + inline void on_error_return(const Observer&) { + onerrors++; + } + + template + inline void on_completed_return(const Observer&) { + oncompleteds++; + } + + int onnexts; + int onerrors; + int oncompleteds; + int subscribes; + int lifts; + int unsubscribes; + int adds; + int removes; + int actions; + int recurses; + int schedules; + int schedulewhens; +}; + +auto rxcpp_trace_activity(rxcpp::trace_tag) -> trace_calls; + #include "rxcpp/rx.hpp" // create alias' to simplify code // these are owned by the user so that @@ -42,7 +138,12 @@ int main(int argc, char** argv) ++ct; })); - std::cout << "concat_map pythagorian range : " << c << " filtered to, " << ct << " triplets" << std::endl; + std::cout << "concat_map pythagorian range : " << c << " filtered to, " << ct << " triplets." << std::endl; + std::cout << "onnexts: " << rxcpp::trace_activity().onnexts << ", onerrors: " << rxcpp::trace_activity().onerrors << ", oncompleteds: " << rxcpp::trace_activity().oncompleteds << std::endl; + std::cout << "subscribes: " << rxcpp::trace_activity().subscribes << ", lifts: " << rxcpp::trace_activity().lifts << std::endl; + std::cout << "unsubscribes: " << rxcpp::trace_activity().unsubscribes << ", adds: " << rxcpp::trace_activity().adds << ", removes: " << rxcpp::trace_activity().removes << std::endl; + std::cout << "schedules: " << rxcpp::trace_activity().schedules << ", schedulewhens: " << rxcpp::trace_activity().schedulewhens << std::endl; + std::cout << "actions: " << rxcpp::trace_activity().actions << ", recurses: " << rxcpp::trace_activity().recurses << std::endl; return 0; } diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index 80748b3..1800984 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -63,7 +63,10 @@ struct lift : public operator_base void on_subscribe(Subscriber o) const { - source.on_subscribe(chain(std::move(o))); + auto lifted = chain(std::move(o)); + trace_activity().lift_enter(source, chain, o, lifted); + source.on_subscribe(std::move(lifted)); + trace_activity().lift_return(source, chain); } }; diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 2568d9d..86fd34a 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -5,6 +5,8 @@ #if !defined(RXCPP_RX_INCLUDES_HPP) #define RXCPP_RX_INCLUDES_HPP +#include "rx-trace.hpp" + // some configuration macros #if defined(_MSC_VER) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 72a8bb7..806e2c4 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -241,7 +241,10 @@ private: static_assert(std::is_same::value && std::is_convertible::value, "the value types in the sequence must match or be convertible"); static_assert(detail::has_on_subscribe_for::value, "inner must have on_subscribe method that accepts this subscriber "); + trace_activity().subscribe_enter(*this, o); + if (!o.is_subscribed()) { + trace_activity().subscribe_return(*this); return o.get_subscription(); } @@ -270,6 +273,7 @@ private: safe_subscribe(); } + trace_activity().subscribe_return(*this); return o.get_subscription(); } diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 3a36afa..805cb94 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -7,8 +7,19 @@ #include "rx-includes.hpp" +auto rxcpp_trace_activity(...) -> rxcpp::trace_noop; + namespace rxcpp { +// +// create a typedef for rxcpp_trace_type to override the default +// +auto trace_activity() -> decltype(rxcpp_trace_activity(trace_tag()))& { + static decltype(rxcpp_trace_activity(trace_tag())) trace; + return trace; +} + + struct tag_action {}; template class is_action diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 3596a0e..df5f681 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -653,6 +653,7 @@ inline action make_action(F&& f) { // tail-recurse inside of the virtual function call // until a new action, lifetime or scheduler is returned [fn](const schedulable& s, const recurse& r) { + trace_activity().action_enter(s); auto scope = s.set_recursed(r); while (s.is_subscribed()) { r.reset(); @@ -663,7 +664,9 @@ inline action make_action(F&& f) { } break; } + trace_activity().action_recurse(s); } + trace_activity().action_return(s); })); } @@ -732,11 +735,17 @@ auto worker::schedule(Arg0&& a0, ArgN&&... an) const (detail::is_action_function::value || is_subscription::value) && !is_schedulable::value>::type { - inner->schedule(make_schedulable(*this, std::forward(a0), std::forward(an)...)); + auto scbl = make_schedulable(*this, std::forward(a0), std::forward(an)...); + trace_activity().schedule_enter(*inner.get(), scbl); + inner->schedule(std::move(scbl)); + trace_activity().schedule_return(*inner.get()); } template void worker::schedule_rebind(const schedulable& scbl, ArgN&&... an) const { - inner->schedule(make_schedulable(scbl, *this, std::forward(an)...)); + auto rescbl = make_schedulable(scbl, *this, std::forward(an)...); + trace_activity().schedule_enter(*inner.get(), rescbl); + inner->schedule(std::move(rescbl)); + trace_activity().schedule_return(*inner.get()); } template @@ -745,11 +754,17 @@ auto worker::schedule(clock_type::time_point when, Arg0&& a0, ArgN&&... an) cons (detail::is_action_function::value || is_subscription::value) && !is_schedulable::value>::type { - inner->schedule(when, make_schedulable(*this, std::forward(a0), std::forward(an)...)); + auto scbl = make_schedulable(*this, std::forward(a0), std::forward(an)...); + trace_activity().schedule_when_enter(*inner.get(), when, scbl); + inner->schedule(when, std::move(scbl)); + trace_activity().schedule_when_return(*inner.get()); } template void worker::schedule_rebind(clock_type::time_point when, const schedulable& scbl, ArgN&&... an) const { - inner->schedule(when, make_schedulable(scbl, *this, std::forward(an)...)); + auto rescbl = make_schedulable(scbl, *this, std::forward(an)...); + trace_activity().schedule_when_enter(*inner.get(), when, rescbl); + inner->schedule(when, std::move(rescbl)); + trace_activity().schedule_when_return(*inner.get()); } template @@ -776,7 +791,9 @@ void worker::schedule_periodically_rebind(clock_type::time_point initial, clock_ *target += period; self.schedule(*target); }); + trace_activity().schedule_when_enter(*inner.get(), *target, periodic); inner->schedule(*target, periodic); + trace_activity().schedule_when_return(*inner.get()); } namespace detail { diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index bd09873..53fbd92 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -24,18 +24,61 @@ class subscriber : public subscriber_base composite_subscription lifetime; observer_type destination; - struct detacher + struct nextdetacher { - ~detacher() + ~nextdetacher() { + trace_activity().on_next_return(*that); if (that) { that->unsubscribe(); } } - detacher(const this_type* that) + nextdetacher(const this_type* that) : that(that) { } + template + void operator()(U u) { + trace_activity().on_next_enter(*that, u); + that->destination.on_next(std::move(u)); + that = nullptr; + } + const this_type* that; + }; + + struct errordetacher + { + ~errordetacher() + { + trace_activity().on_error_return(*that); + that->unsubscribe(); + } + errordetacher(const this_type* that) + : that(that) + { + } + inline void operator()(std::exception_ptr ex) { + trace_activity().on_error_enter(*that, ex); + that->destination.on_error(std::move(ex)); + } + const this_type* that; + }; + + struct completeddetacher + { + ~completeddetacher() + { + trace_activity().on_completed_return(*that); + that->unsubscribe(); + } + completeddetacher(const this_type* that) + : that(that) + { + } + inline void operator()() { + trace_activity().on_completed_enter(*that); + that->destination.on_completed(); + } const this_type* that; }; @@ -91,23 +134,22 @@ public: if (!is_subscribed()) { return; } - detacher protect(this); - destination.on_next(std::forward(v)); - protect.that = nullptr; + nextdetacher protect(this); + protect(std::forward(v)); } void on_error(std::exception_ptr e) const { if (!is_subscribed()) { return; } - detacher protect(this); - destination.on_error(e); + errordetacher protect(this); + protect(std::move(e)); } void on_completed() const { if (!is_subscribed()) { return; } - detacher protect(this); - destination.on_completed(); + completeddetacher protect(this); + protect(); } // composite_subscription diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 60f445c..3ee8441 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -76,7 +76,6 @@ class subscription : public subscription_base { } virtual void unsubscribe() { - issubscribed = false; } std::atomic issubscribed; }; @@ -95,16 +94,21 @@ private: } virtual void unsubscribe() { if (issubscribed.exchange(false)) { + trace_activity().unsubscribe_enter(*this); inner.unsubscribe(); + trace_activity().unsubscribe_return(*this); } } inner_t inner; }; + +protected: std::shared_ptr state; friend bool operator<(const subscription&, const subscription&); friend bool operator==(const subscription&, const subscription&); +private: subscription(weak_state_type w) : state(w.lock()) { @@ -247,8 +251,9 @@ private: inline void remove(weak_subscription w) { if (issubscribed && !w.expired()) { + auto s = subscription::lock(w); std::unique_lock guard(lock); - subscriptions.erase(subscription::lock(w)); + subscriptions.erase(std::move(s)); } } @@ -394,7 +399,6 @@ public: using subscription::is_subscribed; using subscription::unsubscribe; - using inner_type::remove; using inner_type::clear; inline weak_subscription add(subscription s) const { @@ -403,7 +407,11 @@ public: abort(); //return s.get_weak(); } - return inner_type::add(std::move(s)); + auto that = this->subscription::state.get(); + trace_activity().subscription_add_enter(*that, s); + auto w = inner_type::add(std::move(s)); + trace_activity().subscription_add_return(*that); + return w; } template @@ -411,6 +419,13 @@ public: -> typename std::enable_if::value, weak_subscription>::type { return add(make_subscription(std::move(f))); } + + inline void remove(weak_subscription w) const { + auto that = this->subscription::state.get(); + trace_activity().subscription_remove_enter(*that, w); + inner_type::remove(w); + trace_activity().subscription_remove_return(*that); + } }; inline bool operator<(const composite_subscription& lhs, const composite_subscription& rhs) { diff --git a/Rx/v2/src/rxcpp/rx-trace.hpp b/Rx/v2/src/rxcpp/rx-trace.hpp new file mode 100644 index 0000000..3da4ec8 --- /dev/null +++ b/Rx/v2/src/rxcpp/rx-trace.hpp @@ -0,0 +1,78 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_TRACE_HPP) +#define RXCPP_RX_TRACE_HPP + +#include + +namespace rxcpp { + +struct trace_noop +{ + template + inline void schedule_enter(const Worker&, const Schedulable&) {} + template + inline void schedule_return(const Worker&) {} + template + inline void schedule_when_enter(const Worker&, const When&, const Schedulable&) {} + template + inline void schedule_when_return(const Worker&) {} + + template + inline void action_enter(const Schedulable&) {} + template + inline void action_return(const Schedulable&) {} + template + inline void action_recurse(const Schedulable&) {} + + template + inline void subscribe_enter(const Observable& o, const Subscriber& s) {} + template + inline void subscribe_return(const Observable& o) {} + + template + inline void lift_enter(const OperatorSource&, const OperatorChain&, const Subscriber&, const SubscriberLifted&) {} + template + inline void lift_return(const OperatorSource&, const OperatorChain&) {} + + template + inline void unsubscribe_enter(const SubscriptionState&) {} + template + inline void unsubscribe_return(const SubscriptionState&) {} + + template + inline void subscription_add_enter(const SubscriptionState&, const Subscription&) {} + template + inline void subscription_add_return(const SubscriptionState&) {} + + template + inline void subscription_remove_enter(const SubscriptionState&, const WeakSubscription&) {} + template + inline void subscription_remove_return(const SubscriptionState&) {} + + template + inline void on_next_enter(const Subscriber&, const T&) {} + template + inline void on_next_return(const Subscriber&) {} + + template + inline void on_error_enter(const Subscriber&, const std::exception_ptr&) {} + template + inline void on_error_return(const Subscriber&) {} + + template + inline void on_completed_enter(const Subscriber&) {} + template + inline void on_completed_return(const Subscriber&) {} +}; + +struct trace_tag {}; + +} + +auto rxcpp_trace_activity(...) -> rxcpp::trace_noop; + + +#endif -- GitLab From 0caa97f932c4b96a5964d5c22076634e9fadb1a7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Jul 2014 07:39:29 -0700 Subject: [PATCH 391/782] add create and print. redo lift. arrrggg pulled a thread in lift and it unravelled.. --- Rx/v2/examples/println/main.cpp | 1 + Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp | 8 +- .../operators/rx-distinct_until_changed.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-finally.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 39 +- Rx/v2/src/rxcpp/operators/rx-map.hpp | 11 +- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-window.hpp | 29 +- Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 8 +- Rx/v2/src/rxcpp/rx-coordination.hpp | 22 +- Rx/v2/src/rxcpp/rx-observable.hpp | 97 ++-- Rx/v2/src/rxcpp/rx-predef.hpp | 4 +- Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/rx-subscriber.hpp | 462 ++++++++++++++++-- Rx/v2/src/rxcpp/rx-test.hpp | 10 +- Rx/v2/src/rxcpp/rx-trace.hpp | 38 +- Rx/v2/src/rxcpp/rx-util.hpp | 72 ++- Rx/v2/src/rxcpp/sources/rx-create.hpp | 55 +++ Rx/v2/src/rxcpp/sources/rx-error.hpp | 2 +- Rx/v2/src/rxcpp/subjects/rx-behavior.hpp | 17 +- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 30 +- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 15 +- Rx/v2/test/operators/lift.cpp | 12 +- Rx/v2/test/sources/create.cpp | 46 ++ Rx/v2/test/sources/defer.cpp | 2 +- Rx/v2/test/sources/interval.cpp | 6 +- Rx/v2/test/subscriptions/subscription.cpp | 24 +- projects/CMake/CMakeLists.txt | 1 + 29 files changed, 790 insertions(+), 238 deletions(-) create mode 100644 Rx/v2/src/rxcpp/sources/rx-create.hpp create mode 100644 Rx/v2/test/sources/create.cpp diff --git a/Rx/v2/examples/println/main.cpp b/Rx/v2/examples/println/main.cpp index 6904d7f..efe09ca 100644 --- a/Rx/v2/examples/println/main.cpp +++ b/Rx/v2/examples/println/main.cpp @@ -64,5 +64,6 @@ int main(int argc, char** argv) hello_tpl().subscribe(rxu::println(std::cout)); + hello_tpl().subscribe(rxu::print_delimited_by(std::cout, " and "), rxu::endline(std::cout)); return 0; } diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp index 1a9029a..e3a2970 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp @@ -84,9 +84,9 @@ struct buffer_count dest.on_completed(); } - static subscriber> make(dest_type d, buffer_count_values v) { + static subscriber> make(dest_type d, buffer_count_values v) { auto cs = d.get_subscription(); - return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v))); + return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v))); } }; @@ -105,8 +105,8 @@ public: buffer_count_factory(int c, int s) : count(c), skip(s) {} template auto operator()(Observable&& source) - -> decltype(source.lift(buffer_count::type::value_type>(count, skip))) { - return source.lift(buffer_count::type::value_type>(count, skip)); + -> decltype(source.template lift::type::value_type>>(buffer_count::type::value_type>(count, skip))) { + return source.template lift::type::value_type>>(buffer_count::type::value_type>(count, skip)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp index a5ad360..910edda 100644 --- a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp @@ -62,8 +62,8 @@ class distinct_until_changed_factory public: template auto operator()(Observable&& source) - -> decltype(source.lift(distinct_until_changed::type>::value_type)) { - return source.lift(distinct_until_changed::type>::value_type); + -> decltype(source.template lift::type::value_type>(distinct_until_changed::type>::value_type)) { + return source.template lift::type::value_type>(distinct_until_changed::type>::value_type); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index 6dc727c..775bc16 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -79,8 +79,8 @@ public: filter_factory(test_type p) : predicate(std::move(p)) {} template auto operator()(Observable&& source) - -> decltype(source.lift(filter::type::value_type, test_type>(predicate))) { - return source.lift(filter::type::value_type, test_type>(predicate)); + -> decltype(source.template lift::type::value_type>(filter::type::value_type, test_type>(predicate))) { + return source.template lift::type::value_type>(filter::type::value_type, test_type>(predicate)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-finally.hpp b/Rx/v2/src/rxcpp/operators/rx-finally.hpp index a5d7ef9..6e2b7ad 100644 --- a/Rx/v2/src/rxcpp/operators/rx-finally.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-finally.hpp @@ -76,8 +76,8 @@ public: finally_factory(last_call_type lc) : last_call(std::move(lc)) {} template auto operator()(Observable&& source) - -> decltype(source.lift(filter::type::value_type, last_call_type>(last_call))) { - return source.lift(filter::type::value_type, last_call_type>(last_call)); + -> decltype(source.template lift::type::value_type>(filter::type::value_type, last_call_type>(last_call))) { + return source.template lift::type::value_type>(filter::type::value_type, last_call_type>(last_call)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index 1800984..ad2ec4f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -11,7 +11,7 @@ namespace rxcpp { namespace detail { -template +template struct is_lift_function_for { struct tag_not_valid {}; @@ -23,7 +23,7 @@ struct is_lift_function_for { typedef typename std::decay::type for_type; typedef typename std::decay::type func_type; typedef decltype(check(0)) detail_result; - static const bool value = is_subscriber::value && is_subscriber::value; + static const bool value = is_subscriber::value && is_subscriber::value && std::is_convertible::value; }; } @@ -32,25 +32,22 @@ namespace operators { namespace detail { -template +template struct lift_traits { + typedef typename std::decay::type result_value_type; typedef typename std::decay::type source_operator_type; typedef typename std::decay::type operator_type; typedef typename source_operator_type::value_type source_value_type; - static_assert(rxcpp::detail::is_lift_function_for, operator_type>::value, "lift Operator must be a function with the signature subscriber<...>(subscriber)"); - - typedef decltype((*(operator_type*)nullptr)(*(subscriber*)nullptr)) result_for_dynamic_source_subscriber_type; - - typedef typename result_for_dynamic_source_subscriber_type::value_type result_value_type; + static_assert(rxcpp::detail::is_lift_function_for, operator_type>::value, "lift Operator must be a function with the signature subscriber(subscriber)"); }; -template -struct lift : public operator_base::result_value_type> +template +struct lift : public operator_base::result_value_type> { - typedef lift_traits traits; + typedef lift_traits traits; typedef typename traits::source_operator_type source_operator_type; typedef typename traits::operator_type operator_type; source_operator_type source; @@ -70,6 +67,26 @@ struct lift : public operator_base +class lift_factory +{ + typedef typename std::decay::type operator_type; + operator_type chain; +public: + lift_factory(operator_type op) : chain(std::move(op)) {} + template + auto operator()(Observable&& source) + -> decltype(source.template lift(chain)) { + return source.template lift(chain); + } +}; + +} + +template +auto lift(Operator&& op) + -> detail::lift_factory { + return detail::lift_factory(std::forward(op)); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 19e31d2..1de7602 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -19,6 +19,7 @@ struct map { typedef typename std::decay::type source_value_type; typedef typename std::decay::type select_type; + typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; select_type selector; map(select_type s) @@ -32,7 +33,7 @@ struct map typedef map_observer this_type; typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; typedef typename std::decay::type dest_type; - typedef observer observer_type; + typedef observer observer_type; dest_type dest; select_type selector; @@ -58,9 +59,9 @@ struct map dest.on_completed(); } - static subscriber> make(dest_type d, select_type s) { + static subscriber make(dest_type d, select_type s) { auto cs = d.get_subscription(); - return make_subscriber(std::move(cs), this_type(std::move(d), std::move(s))); + return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(s)))); } }; @@ -80,8 +81,8 @@ public: map_factory(select_type s) : selector(std::move(s)) {} template auto operator()(Observable&& source) - -> decltype(source.lift(map::type::value_type, select_type>(selector))) { - return source.lift(map::type::value_type, select_type>(selector)); + -> decltype(source.lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector))) { + return source.lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 8e6c18d..c1157de 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -193,8 +193,8 @@ public: observe_on_factory(coordination_type cn) : coordination(std::move(cn)) {} template auto operator()(Observable&& source) - -> decltype(source.lift(observe_on::type::value_type, coordination_type>(coordination))) { - return source.lift(observe_on::type::value_type, coordination_type>(coordination)); + -> decltype(source.template lift::type::value_type>(observe_on::type::value_type, coordination_type>(coordination))) { + return source.template lift::type::value_type>(observe_on::type::value_type, coordination_type>(coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window.hpp b/Rx/v2/src/rxcpp/operators/rx-window.hpp index d87285d..c2bf220 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window.hpp @@ -35,22 +35,6 @@ struct window { } - struct window_observable : public sources::source_base - { - mutable rxcpp::subjects::subject subj; - - window_observable(rxcpp::subjects::subject s) - : subj(std::move(s)) - { - } - - template - void on_subscribe(Subscriber o) const { - static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - subj.get_observable().subscribe(o); - } - }; - template struct window_observer : public window_values, public observer_base> { @@ -58,6 +42,7 @@ struct window typedef observer_base> base_type; typedef typename base_type::value_type value_type; typedef typename std::decay::type dest_type; + typedef observer observer_type; dest_type dest; mutable int cursor; mutable std::deque> subj; @@ -68,7 +53,7 @@ struct window , cursor(0) { subj.push_back(rxcpp::subjects::subject()); - dest.on_next(observable(window_observable(subj[0]))); + dest.on_next(subj[0].get_observable().as_dynamic()); } void on_next(T v) const { for (auto s : subj) { @@ -83,7 +68,7 @@ struct window if (++cursor % this->skip == 0) { subj.push_back(rxcpp::subjects::subject()); - dest.on_next(observable(window_observable(subj[subj.size() - 1]))); + dest.on_next(subj[subj.size() - 1].get_observable().as_dynamic()); } } @@ -101,9 +86,9 @@ struct window dest.on_completed(); } - static subscriber make(dest_type d, window_values v) { + static subscriber make(dest_type d, window_values v) { auto cs = d.get_subscription(); - return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v))); + return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(v)))); } }; @@ -122,8 +107,8 @@ public: window_factory(int c, int s) : count(c), skip(s) {} template auto operator()(Observable&& source) - -> decltype(source.lift(window::type::value_type>(count, skip))) { - return source.lift(window::type::value_type>(count, skip)); + -> decltype(source.template lift::type::value_type>>(window::type::value_type>(count, skip))) { + return source.template lift::type::value_type>>(window::type::value_type>(count, skip)); } }; diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index 445e261..0352605 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -206,8 +206,8 @@ public: // template auto operator >> (const rxcpp::connectable_observable& source, OperatorFactory&& of) - -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { - return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } // @@ -216,8 +216,8 @@ auto operator >> (const rxcpp::connectable_observable& source // template auto operator | (const rxcpp::connectable_observable& source, OperatorFactory&& of) - -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { - return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } #endif diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index cbe030d..abd1506 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -195,13 +195,12 @@ class serialize_one_worker : public coordination_base } }; - template - struct serialize_observer : public observer_base + template + struct serialize_observer { - typedef serialize_observer this_type; - typedef observer_base base_type; - typedef typename base_type::value_type value_type; - typedef typename std::decay::type dest_type; + typedef serialize_observer this_type; + typedef typename std::decay::type dest_type; + typedef typename dest_type::value_type value_type; typedef observer observer_type; dest_type dest; std::shared_ptr lock; @@ -227,8 +226,9 @@ class serialize_one_worker : public coordination_base dest.on_completed(); } - static subscriber make(dest_type d, std::shared_ptr m) { - return make_subscriber(d, this_type(d, std::move(m))); + template + static subscriber make(const Subscriber& s, std::shared_ptr m) { + return make_subscriber(s, observer_type(this_type(s.get_observer(), std::move(m)))); } }; @@ -259,9 +259,9 @@ class serialize_one_worker : public coordination_base return std::move(o); } template - auto out(Subscriber s) const - -> decltype(serialize_observer::make(std::move(s), lock)) { - return serialize_observer::make(std::move(s), lock); + auto out(const Subscriber& s) const + -> decltype(serialize_observer::make(s, lock)) { + return serialize_observer::make(s, lock); } template auto act(F f) const diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 806e2c4..944d230 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -46,38 +46,6 @@ struct has_on_subscribe_for static const bool value = std::is_same::value; }; -struct lift_function { -template -static auto chain(const SourceObservable& source, OperatorFactory&& of) - -> decltype(source.lift(std::forward(of))) { - return source.lift(std::forward(of)); -} -}; -struct operator_factory { -template -static auto chain(const SourceObservable& source, OperatorFactory&& of) - -> decltype(source.op(std::forward(of))) { - return source.op(std::forward(of)); -} -}; -struct not_chainable { -}; - -template -struct select_chain -{ - typedef - typename std::conditional< - rxcpp::detail::is_lift_function_for, OperatorFactory>::value, - lift_function, - typename std::conditional< - rxcpp::detail::is_operator_factory_for::value, - operator_factory, - not_chainable - >::type - >::type type; -}; - } template @@ -131,9 +99,9 @@ public: } template - typename std::enable_if>::value, void>::type + typename std::enable_if::value, void>::type on_subscribe(Subscriber o) const { - state->on_subscribe(make_subscriber(o, make_observer_dynamic(o.get_observer()))); + state->on_subscribe(o.as_dynamic()); } }; @@ -237,7 +205,7 @@ private: typedef typename std::decay::type subscriber_type; - static_assert(is_observer::value, "subscribe must be passed an observer"); + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); static_assert(std::is_same::value && std::is_convertible::value, "the value types in the sequence must match or be convertible"); static_assert(detail::has_on_subscribe_for::value, "inner must have on_subscribe method that accepts this subscriber "); @@ -337,12 +305,12 @@ public: /// this is intended to allow externally defined operators, that use make_subscriber, to be connected /// into the expression. /// - template + template auto lift(Operator&& op) const - -> observable::value_type, rxo::detail::lift> { - return observable::value_type, rxo::detail::lift>( - rxo::detail::lift(source_operator, std::forward(op))); - static_assert(detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); + -> observable::value_type, rxo::detail::lift> { + return observable::value_type, rxo::detail::lift>( + rxo::detail::lift(source_operator, std::forward(op))); + static_assert(detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); } /// @@ -366,16 +334,16 @@ public: /// template auto filter(Predicate p) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::filter(std::move(p)))) { - return lift(rxo::detail::filter(std::move(p))); + -> decltype(EXPLICIT_THIS lift(rxo::detail::filter(std::move(p)))) { + return lift(rxo::detail::filter(std::move(p))); } /// finally () -> /// template auto finally(LastCall lc) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::finally(std::move(lc)))) { - return lift(rxo::detail::finally(std::move(lc))); + -> decltype(EXPLICIT_THIS lift(rxo::detail::finally(std::move(lc)))) { + return lift(rxo::detail::finally(std::move(lc))); } /// map (AKA Select) -> @@ -383,48 +351,48 @@ public: /// template auto map(Selector&& s) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::map(std::move(s)))) { - return lift(rxo::detail::map(std::move(s))); + -> decltype(EXPLICIT_THIS lift::value_type>(rxo::detail::map(std::move(s)))) { + return lift::value_type>(rxo::detail::map(std::move(s))); } /// distinct_until_changed -> /// for each item from this observable, filter out repeated values and emit only changes from the new observable that is returned. /// auto distinct_until_changed() const - -> decltype(EXPLICIT_THIS lift(rxo::detail::distinct_until_changed())) { - return lift(rxo::detail::distinct_until_changed()); + -> decltype(EXPLICIT_THIS lift(rxo::detail::distinct_until_changed())) { + return lift(rxo::detail::distinct_until_changed()); } /// window -> /// produce observables containing count items emitted by this observable /// auto window(int count) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::window(count, count))) { - return lift(rxo::detail::window(count, count)); + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window(count, count))) { + return lift>(rxo::detail::window(count, count)); } /// window -> /// produce observables containing count items emitted by this observable /// auto window(int count, int skip) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::window(count, skip))) { - return lift(rxo::detail::window(count, skip)); + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window(count, skip))) { + return lift>(rxo::detail::window(count, skip)); } /// buffer -> /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// auto buffer(int count) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::buffer_count(count, count))) { - return lift(rxo::detail::buffer_count(count, count)); + -> decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_count(count, count))) { + return lift>(rxo::detail::buffer_count(count, count)); } /// buffer -> /// start a new vector every skip items and collect count items from this observable into each vector to emit from the new observable that is returned. /// auto buffer(int count, int skip) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::buffer_count(count, skip))) { - return lift(rxo::detail::buffer_count(count, skip)); + -> decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_count(count, skip))) { + return lift>(rxo::detail::buffer_count(count, skip)); } template @@ -747,8 +715,8 @@ public: /// template auto observe_on(Coordination cn) const - -> decltype(EXPLICIT_THIS lift(rxo::detail::observe_on(std::move(cn)))) { - return lift(rxo::detail::observe_on(std::move(cn))); + -> decltype(EXPLICIT_THIS lift(rxo::detail::observe_on(std::move(cn)))) { + return lift(rxo::detail::observe_on(std::move(cn))); } /// reduce -> @@ -960,6 +928,11 @@ class observable { ~observable(); public: + template + static auto create(OnSubscribe os) + -> decltype(rxs::create(std::move(os))) { + return rxs::create(std::move(os)); + } template static auto range(T first = 0, T last = std::numeric_limits::max(), ptrdiff_t step = 1) -> decltype(rxs::range(first, last, step, identity_current_thread())) { @@ -1087,8 +1060,8 @@ public: // template auto operator >> (const rxcpp::observable& source, OperatorFactory&& of) - -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { - return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } // @@ -1097,8 +1070,8 @@ auto operator >> (const rxcpp::observable& source, OperatorFa // template auto operator | (const rxcpp::observable& source, OperatorFactory&& of) - -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { - return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } #endif diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 805cb94..1b82f40 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -7,14 +7,12 @@ #include "rx-includes.hpp" -auto rxcpp_trace_activity(...) -> rxcpp::trace_noop; - namespace rxcpp { // // create a typedef for rxcpp_trace_type to override the default // -auto trace_activity() -> decltype(rxcpp_trace_activity(trace_tag()))& { +inline auto trace_activity() -> decltype(rxcpp_trace_activity(trace_tag()))& { static decltype(rxcpp_trace_activity(trace_tag())) trace; return trace; } diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index b4205ff..c9fb73f 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -35,6 +35,7 @@ namespace rxs=sources; } +#include "sources/rx-create.hpp" #include "sources/rx-range.hpp" #include "sources/rx-iterate.hpp" #include "sources/rx-interval.hpp" diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 53fbd92..dbb3615 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -18,32 +18,37 @@ struct subscriber_base : public observer_base, public subscription_base template> class subscriber : public subscriber_base { + static_assert(!is_subscriber::value, "not allowed to nest subscribers"); + static_assert(is_observer::value, "subscriber must contain an observer"); typedef subscriber this_type; typedef typename std::decay::type observer_type; composite_subscription lifetime; observer_type destination; + trace_id id; struct nextdetacher { ~nextdetacher() { trace_activity().on_next_return(*that); - if (that) { + if (do_unsubscribe) { that->unsubscribe(); } } nextdetacher(const this_type* that) : that(that) + , do_unsubscribe(true) { } template void operator()(U u) { trace_activity().on_next_enter(*that, u); that->destination.on_next(std::move(u)); - that = nullptr; + do_unsubscribe = false; } const this_type* that; + bool do_unsubscribe; }; struct errordetacher @@ -89,24 +94,31 @@ public: subscriber(const this_type& o) : lifetime(o.lifetime) , destination(o.destination) + , id(o.id) { } subscriber(this_type&& o) : lifetime(std::move(o.lifetime)) , destination(std::move(o.destination)) + , id(std::move(o.id)) { } template - subscriber(composite_subscription cs, U&& o) + subscriber(trace_id id, composite_subscription cs, U&& o) : lifetime(std::move(cs)) , destination(std::forward(o)) + , id(std::move(id)) { + static_assert(!is_subscriber::value, "cannot nest subscribers"); + static_assert(is_observer::value, "must pass observer to subscriber"); + trace_activity().create_subscriber(*this); } this_type& operator=(this_type o) { lifetime = std::move(o.lifetime); destination = std::move(o.destination); + id = std::move(o.id); return *this; } @@ -122,9 +134,12 @@ public: composite_subscription& get_subscription() { return lifetime; } + trace_id get_id() const { + return id; + } subscriber as_dynamic() const { - return subscriber(lifetime, destination.as_dynamic()); + return subscriber(id, lifetime, destination.as_dynamic()); } // observer @@ -192,7 +207,7 @@ auto make_subscriber() -> typename std::enable_if< detail::is_on_next_of>::value, subscriber>>>>::type { - return subscriber>>>(composite_subscription(), + return subscriber>>>(trace_id::make_next_id_subscriber(), composite_subscription(), observer>>( static_observer>(detail::OnNextEmpty()))); } @@ -201,14 +216,14 @@ template auto make_subscriber( const observer& o) -> subscriber> { - return subscriber>(composite_subscription(), o); + return subscriber>(trace_id::make_next_id_subscriber(), composite_subscription(), o); } template auto make_subscriber(const Observer& o) -> typename std::enable_if< is_observer::value, subscriber>::type { - return subscriber(composite_subscription(), o); + return subscriber(trace_id::make_next_id_subscriber(), composite_subscription(), o); } template auto make_subscriber(const Observer& o) @@ -218,14 +233,14 @@ auto make_subscriber(const Observer& o) !is_subscription::value && !is_observer::value, subscriber>>::type { - return subscriber>(composite_subscription(), o); + return subscriber>(trace_id::make_next_id_subscriber(), composite_subscription(), o); } template auto make_subscriber(const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), + return subscriber>>(trace_id::make_next_id_subscriber(), composite_subscription(), observer>( static_observer(on))); } @@ -235,7 +250,7 @@ auto make_subscriber(const OnNext& on, const OnError& oe) detail::is_on_next_of::value && detail::is_on_error::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), + return subscriber>>(trace_id::make_next_id_subscriber(), composite_subscription(), observer>( static_observer(on, oe))); } @@ -245,7 +260,7 @@ auto make_subscriber(const OnNext& on, const OnCompleted& oc) detail::is_on_next_of::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), + return subscriber>>(trace_id::make_next_id_subscriber(), composite_subscription(), observer>( static_observer(on, detail::OnErrorEmpty(), oc))); } @@ -256,7 +271,7 @@ auto make_subscriber(const OnNext& on, const OnError& oe, const OnCompleted& oc) detail::is_on_error::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(composite_subscription(), + return subscriber>>(trace_id::make_next_id_subscriber(), composite_subscription(), observer>( static_observer(on, oe, oc))); } @@ -267,7 +282,7 @@ auto make_subscriber(const OnNext& on, const OnError& oe, const OnCompleted& oc) template auto make_subscriber(const composite_subscription& cs) -> subscriber>>> { - return subscriber>>>(cs, + return subscriber>>>(trace_id::make_next_id_subscriber(), cs, observer>>( static_observer>(detail::OnNextEmpty()))); } @@ -276,14 +291,21 @@ template auto make_subscriber(const composite_subscription& cs, const observer& o) -> subscriber> { - return subscriber>(cs, o); + return subscriber>(trace_id::make_next_id_subscriber(), cs, o); +} +template +auto make_subscriber(const composite_subscription& cs, + const subscriber& s) + -> subscriber { + return subscriber(trace_id::make_next_id_subscriber(), cs, s.get_observer()); } template auto make_subscriber(const composite_subscription& cs, const Observer& o) -> typename std::enable_if< + !is_subscriber::value && is_observer::value, subscriber>::type { - return subscriber(cs, o); + return subscriber(trace_id::make_next_id_subscriber(), cs, o); } template auto make_subscriber(const composite_subscription& cs, const Observer& o) @@ -293,14 +315,14 @@ auto make_subscriber(const composite_subscription& cs, const Observer& o) !is_subscription::value && !is_observer::value, subscriber>>::type { - return subscriber>(cs, o); + return subscriber>(trace_id::make_next_id_subscriber(), cs, make_observer(o)); } template auto make_subscriber(const composite_subscription& cs, const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, subscriber>>>::type { - return subscriber>>(cs, + return subscriber>>(trace_id::make_next_id_subscriber(), cs, observer>( static_observer(on))); } @@ -310,7 +332,7 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O detail::is_on_next_of::value && detail::is_on_error::value, subscriber>>>::type { - return subscriber>>(cs, + return subscriber>>(trace_id::make_next_id_subscriber(), cs, observer>( static_observer(on, oe))); } @@ -320,7 +342,7 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O detail::is_on_next_of::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(cs, + return subscriber>>(trace_id::make_next_id_subscriber(), cs, observer>( static_observer(on, detail::OnErrorEmpty(), oc))); } @@ -331,7 +353,153 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O detail::is_on_error::value && detail::is_on_completed::value, subscriber>>>::type { - return subscriber>>(cs, + return subscriber>>(trace_id::make_next_id_subscriber(), cs, + observer>( + static_observer(on, oe, oc))); +} + +// explicit id +// + +template +auto make_subscriber(trace_id id) + -> subscriber>>> { + return subscriber>>>(std::move(id), composite_subscription(), + observer>>( + static_observer>(detail::OnNextEmpty()))); +} + +template +auto make_subscriber(trace_id id, const composite_subscription& cs) + -> subscriber>>> { + return subscriber>>>(std::move(id), cs, + observer>>( + static_observer>(detail::OnNextEmpty()))); +} + +template +auto make_subscriber(trace_id id, + const observer& o) + -> subscriber> { + return subscriber>(std::move(id), composite_subscription(), o); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, + const observer& o) + -> subscriber> { + return subscriber>(std::move(id), cs, o); +} +template +auto make_subscriber(trace_id id, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(std::move(id), composite_subscription(), o); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + return subscriber(std::move(id), cs, o); +} +template +auto make_subscriber(trace_id id, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + return subscriber>(std::move(id), composite_subscription(), o); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + return subscriber>(std::move(id), cs, o); +} +template +auto make_subscriber(trace_id id, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(std::move(id), composite_subscription(), + observer>( + static_observer(on))); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + return subscriber>>(std::move(id), cs, + observer>( + static_observer(on))); +} +template +auto make_subscriber(trace_id id, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(std::move(id), composite_subscription(), + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + return subscriber>>(std::move(id), cs, + observer>( + static_observer(on, oe))); +} +template +auto make_subscriber(trace_id id, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(std::move(id), composite_subscription(), + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(std::move(id), cs, + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); +} +template +auto make_subscriber(trace_id id, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(std::move(id), composite_subscription(), + observer>( + static_observer(on, oe, oc))); +} +template +auto make_subscriber(trace_id id, const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + return subscriber>>(std::move(id), cs, observer>( static_observer(on, oe, oc))); } @@ -342,15 +510,37 @@ auto make_subscriber(const composite_subscription& cs, const OnNext& on, const O template auto make_subscriber(const subscriber& scbr, const observer& o) - -> subscriber> { - return subscriber>(scbr.get_subscription(), o); + -> subscriber> { + auto r = subscriber>(trace_id::make_next_id_subscriber(), scbr.get_subscription(), o); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, + const observer& o) + -> subscriber> { + auto r = subscriber>(std::move(id), scbr.get_subscription(), o); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + auto r = subscriber(std::move(id), scbr.get_subscription(), o); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const Observer& o) -> typename std::enable_if< + !is_subscription::value && is_observer::value, - subscriber>::type { - return subscriber(scbr.get_subscription(), o); + subscriber>::type { + auto r = subscriber(trace_id::make_next_id_subscriber(), scbr.get_subscription(), o); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const Observer& o) @@ -359,37 +549,92 @@ auto make_subscriber(const subscriber& scbr, const Observ !is_subscriber::value && !is_subscription::value && !is_observer::value, - subscriber>>::type { - return subscriber>(scbr.get_subscription(), o); + subscriber>>::type { + auto r = subscriber>(trace_id::make_next_id_subscriber(), scbr.get_subscription(), make_observer(o)); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + auto r = subscriber>(std::move(id), scbr.get_subscription(), o); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), scbr.get_subscription(), + observer>( + static_observer(on))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), scbr.get_subscription(), observer>( static_observer(on))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const OnNext& on, const OnError& oe) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_error::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), scbr.get_subscription(), + observer>( + static_observer(on, oe))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), scbr.get_subscription(), observer>( static_observer(on, oe))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const OnNext& on, const OnCompleted& oc) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), scbr.get_subscription(), + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), scbr.get_subscription(), observer>( static_observer(on, detail::OnErrorEmpty(), oc))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const OnNext& on, const OnError& oe, const OnCompleted& oc) @@ -397,24 +642,56 @@ auto make_subscriber(const subscriber& scbr, const OnNext detail::is_on_next_of::value && detail::is_on_error::value && detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(scbr.get_subscription(), + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), scbr.get_subscription(), + observer>( + static_observer(on, oe, oc))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), scbr.get_subscription(), observer>( static_observer(on, oe, oc))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const observer& o) -> subscriber> { - return subscriber>(cs, o); + return subscriber>(trace_id::make_next_id_subscriber(), cs, o); +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, + const observer& o) + -> subscriber> { + return subscriber>(std::move(id), cs, o); } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const Observer& o) -> typename std::enable_if< is_observer::value, - subscriber>::type { - return subscriber(cs, o); + subscriber>::type { + auto r = subscriber(trace_id::make_next_id_subscriber(), cs, o); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + is_observer::value, + subscriber>::type { + auto r = subscriber(std::move(id), cs, o); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const Observer& o) @@ -423,37 +700,92 @@ auto make_subscriber(const subscriber& scbr, const compos !is_subscriber::value && !is_subscription::value && !is_observer::value, - subscriber>>::type { - return subscriber>(cs, o); + subscriber>>::type { + auto r = subscriber>(trace_id::make_next_id_subscriber(), cs, o); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, const Observer& o) + -> typename std::enable_if< + !detail::is_on_next_of::value && + !is_subscriber::value && + !is_subscription::value && + !is_observer::value, + subscriber>>::type { + auto r = subscriber>(std::move(id), cs, o); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on) -> typename std::enable_if< detail::is_on_next_of::value, - subscriber>>>::type { - return subscriber>>(cs, + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), cs, + observer>( + static_observer(on))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, const OnNext& on) + -> typename std::enable_if< + detail::is_on_next_of::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), cs, observer>( static_observer(on))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnError& oe) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_error::value, - subscriber>>>::type { - return subscriber>>(cs, + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), cs, + observer>( + static_observer(on, oe))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, const OnNext& on, const OnError& oe) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), cs, observer>( static_observer(on, oe))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnCompleted& oc) -> typename std::enable_if< detail::is_on_next_of::value && detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(cs, + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), cs, + observer>( + static_observer(on, detail::OnErrorEmpty(), oc))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, const OnNext& on, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_completed::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), cs, observer>( static_observer(on, detail::OnErrorEmpty(), oc))); + trace_activity().connect(r, scbr); + return r; } template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) @@ -461,18 +793,48 @@ auto make_subscriber(const subscriber& scbr, const compos detail::is_on_next_of::value && detail::is_on_error::value && detail::is_on_completed::value, - subscriber>>>::type { - return subscriber>>(cs, + subscriber>>>::type { + auto r = subscriber>>(trace_id::make_next_id_subscriber(), cs, + observer>( + static_observer(on, oe, oc))); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, const OnNext& on, const OnError& oe, const OnCompleted& oc) + -> typename std::enable_if< + detail::is_on_next_of::value && + detail::is_on_error::value && + detail::is_on_completed::value, + subscriber>>>::type { + auto r = subscriber>>(std::move(id), cs, observer>( static_observer(on, oe, oc))); + trace_activity().connect(r, scbr); + return r; } -// override lifetime -// template auto make_subscriber(const subscriber& scbr, const composite_subscription& cs) -> subscriber { - return subscriber(cs, scbr.get_observer()); + auto r = subscriber(scbr.get_id(), cs, scbr.get_observer()); + trace_activity().connect(r, scbr); + return r; +} +template +auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs) + -> subscriber { + auto r = subscriber(std::move(id), cs, scbr.get_observer()); + trace_activity().connect(r, scbr); + return r; +} + +template +auto make_subscriber(const subscriber& scbr, trace_id id) + -> subscriber { + auto r = subscriber(std::move(id), scbr.get_subscription(), scbr.get_observer()); + trace_activity().connect(r, scbr); + return r; } } diff --git a/Rx/v2/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp index cf4841b..542c55b 100644 --- a/Rx/v2/src/rxcpp/rx-test.hpp +++ b/Rx/v2/src/rxcpp/rx-test.hpp @@ -42,7 +42,7 @@ struct test_source static_assert(is_subscriber::value, "on_subscribe must be passed a subscriber."); - ts->on_subscribe(make_subscriber(o, make_observer_dynamic(o.get_observer()))); + ts->on_subscribe(o.as_dynamic()); } }; @@ -111,8 +111,8 @@ namespace rxt=test; // template auto operator >> (const rxcpp::test::testable_observable& source, OperatorFactory&& of) - -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { - return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } // @@ -121,8 +121,8 @@ auto operator >> (const rxcpp::test::testable_observable& source, OperatorFac // template auto operator | (const rxcpp::test::testable_observable& source, OperatorFactory&& of) - -> decltype(rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of))) { - return rxcpp::detail::select_chain, OperatorFactory>::type::chain(source, std::forward(of)); + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); } #include "schedulers/rx-test.hpp" diff --git a/Rx/v2/src/rxcpp/rx-trace.hpp b/Rx/v2/src/rxcpp/rx-trace.hpp index 3da4ec8..e72caaf 100644 --- a/Rx/v2/src/rxcpp/rx-trace.hpp +++ b/Rx/v2/src/rxcpp/rx-trace.hpp @@ -5,10 +5,40 @@ #if !defined(RXCPP_RX_TRACE_HPP) #define RXCPP_RX_TRACE_HPP +#include #include +#include namespace rxcpp { +struct trace_id +{ + static inline trace_id make_next_id_subscriber() { + static std::atomic id(0xB0000000); + return trace_id{++id}; + } + unsigned long id; +}; + +inline bool operator==(const trace_id& lhs, const trace_id& rhs) { + return lhs.id == rhs.id; +} +inline bool operator!=(const trace_id& lhs, const trace_id& rhs) { + return !(lhs==rhs); +} + +inline bool operator<(const trace_id& lhs, const trace_id& rhs) { + if ((lhs.id & 0xF0000000) != (rhs.id & 0xF0000000)) std::terminate(); + return lhs.id < rhs.id; +} +inline bool operator>(const trace_id& lhs, const trace_id& rhs) { + return rhs @@ -32,6 +62,9 @@ struct trace_noop template inline void subscribe_return(const Observable& o) {} + template + inline void connect(const SubscriberFrom&, const SubscriberTo&) {} + template inline void lift_enter(const OperatorSource&, const OperatorChain&, const Subscriber&, const SubscriberLifted&) {} template @@ -52,6 +85,9 @@ struct trace_noop template inline void subscription_remove_return(const SubscriptionState&) {} + template + inline void create_subscriber(const Subscriber&) {} + template inline void on_next_enter(const Subscriber&, const T&) {} template @@ -72,7 +108,7 @@ struct trace_tag {}; } -auto rxcpp_trace_activity(...) -> rxcpp::trace_noop; +inline auto rxcpp_trace_activity(...) -> rxcpp::trace_noop; #endif diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 06da93e..9e613c4 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -261,27 +261,85 @@ struct plus { return std::forward(lhs) + std::forward(rhs); } }; -template -struct println_function +namespace detail { +template +struct print_function { OStream& os; - println_function(OStream& os) : os(os) {} + Delimit delimit; + print_function(OStream& os, Delimit d) : os(os), delimit(std::move(d)) {} template void operator()(const TN&... tn) const { bool inserts[] = {(os << tn, true)...}; - os << std::endl; + delimit(); } template void operator()(const std::tuple& tpl) const { - apply(tpl, *this); + rxcpp::util::apply(tpl, *this); } }; + +template +struct endline +{ + OStream& os; + endline(OStream& os) : os(os) {} + void operator()() const { + os << std::endl; + } +}; + +template +struct insert_value +{ + OStream& os; + ValueType value; + insert_value(OStream& os, ValueType v) : os(os), value(std::move(v)) {} + void operator()() const { + os << value; + } +}; + +template +struct insert_function +{ + OStream& os; + Function call; + insert_function(OStream& os, Function f) : os(os), call(std::move(f)) {} + void operator()() const { + call(os); + } +}; + +} + +template +auto endline(OStream& os) + -> detail::endline { + return detail::endline(os); +} + +template +auto print(OStream& os, Delimit d) + -> decltype(d(), detail::print_function(os, std::move(d))) { + return detail::print_function(os, std::move(d)); +} +template +auto print(OStream& os, Delimit d) + -> decltype(d(os), detail::print_function>(os, detail::insert_function(os, std::move(d)))) { + return detail::print_function>(os, detail::insert_function(os, std::move(d))); +} template auto println(OStream& os) - -> println_function { - return println_function(os); + -> decltype(print(os, endline(os))) { + return print(os, endline(os)); +} +template +auto print_delimited_by(OStream& os, DelimitValue dv) + -> detail::print_function> { + return detail::print_function>(os, detail::insert_value(os, std::move(dv))); } namespace detail { diff --git a/Rx/v2/src/rxcpp/sources/rx-create.hpp b/Rx/v2/src/rxcpp/sources/rx-create.hpp new file mode 100644 index 0000000..2c50e98 --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-create.hpp @@ -0,0 +1,55 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_CREATE_HPP) +#define RXCPP_SOURCES_RX_CREATE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct create : public source_base +{ + typedef create this_type; + + typedef typename std::decay::type on_subscribe_type; + + on_subscribe_type on_subscribe_function; + + create(on_subscribe_type os) + : on_subscribe_function(std::move(os)) + { + } + + template + void on_subscribe(Subscriber o) const { + + on_exception( + [&](){ + this->on_subscribe_function(o); + return true; + }, + o); + } +}; + +} + +template +auto create(OnSubscribe os) + -> observable> { + return observable>( + detail::create(std::move(os))); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index 4b2c4bb..5014c7c 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -44,7 +44,7 @@ struct error : public source_base // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); - auto controller = coordinator.get_output().get_worker(); + auto controller = coordinator.get_worker(); auto exception = initial.exception; auto producer = [=](const rxsc::schedulable&){ diff --git a/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp b/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp index 539f8d6..ff3becb 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-behavior.hpp @@ -49,6 +49,10 @@ public: { } + subscriber get_subscriber() const { + return make_subscriber(this->get_id(), this->get_subscription(), observer>(*this)).as_dynamic(); + } + T get_value() const { return state->get(); } @@ -65,13 +69,11 @@ public: template class behavior { - composite_subscription lifetime; detail::behavior_observer s; public: explicit behavior(T f, composite_subscription cs = composite_subscription()) - : lifetime(std::move(cs)) - , s(std::move(f), lifetime) + : s(std::move(f), cs) { } @@ -84,15 +86,16 @@ public: } subscriber get_subscriber() const { - return make_subscriber(lifetime, make_observer_dynamic(observer>(s))); + return s.get_subscriber(); } observable get_observable() const { - return make_observable_dynamic([this](subscriber o){ - if (lifetime.is_subscribed()) { + auto keepAlive = s; + return make_observable_dynamic([=](subscriber o){ + if (keepAlive.get_subscription().is_subscribed()) { o.on_next(get_value()); } - this->s.add(std::move(o)); + keepAlive.add(s.get_subscriber(), std::move(o)); }); } }; diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index eff91c9..e07cc69 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -77,12 +77,15 @@ class multicast_observer { explicit binder_type(composite_subscription cs) : state(std::make_shared(cs)) + , id(trace_id::make_next_id_subscriber()) , current_generation(0) { } std::shared_ptr state; + trace_id id; + // used to avoid taking lock in on_next mutable int current_generation; mutable std::shared_ptr current_completer; @@ -93,18 +96,29 @@ class multicast_observer std::shared_ptr b; - - public: + typedef subscriber>> input_subscriber_type; + explicit multicast_observer(composite_subscription cs) : b(std::make_shared(cs)) { } + trace_id get_id() const { + return b->id; + } + composite_subscription get_subscription() const { + return b->state->lifetime; + } + input_subscriber_type get_subscriber() const { + return make_subscriber(get_id(), get_subscription(), observer>(*this)); + } bool has_observers() const { std::unique_lock guard(b->state->lock); return b->current_completer && !b->current_completer->observers.empty(); } - void add(observer_type o) const { + template + void add(const SubscriberFrom& sf, observer_type o) const { + trace_activity().connect(sf, o); std::unique_lock guard(b->state->lock); switch (b->state->current) { case mode::Casting: @@ -197,17 +211,15 @@ public: template class subject { - composite_subscription lifetime; detail::multicast_observer s; public: subject() - : s(lifetime) + : s(composite_subscription()) { } explicit subject(composite_subscription cs) - : lifetime(cs) - , s(cs) + : s(cs) { } @@ -216,13 +228,13 @@ public: } subscriber>> get_subscriber() const { - return make_subscriber(lifetime, observer>(s)); + return s.get_subscriber(); } observable get_observable() const { auto keepAlive = s; return make_observable_dynamic([=](subscriber o){ - keepAlive.add(std::move(o)); + keepAlive.add(s.get_subscriber(), std::move(o)); }); } }; diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index c28fa91..564f564 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -143,6 +143,10 @@ public: state = std::make_shared(std::move(coordinator), std::move(il), std::move(o)); } + subscriber get_subscriber() const { + return make_subscriber(this->get_id(), state->lifetime, observer>(*this)).as_dynamic(); + } + template void on_next(V v) const { state->on_next(std::move(v)); @@ -160,13 +164,11 @@ public: template class synchronize { - composite_subscription lifetime; detail::synchronize_observer s; public: explicit synchronize(Coordination cn, composite_subscription cs = composite_subscription()) - : lifetime(composite_subscription()) - , s(std::move(cn), std::move(cs), lifetime) + : s(std::move(cn), std::move(cs), composite_subscription()) { } @@ -175,12 +177,13 @@ public: } subscriber get_subscriber() const { - return make_subscriber(lifetime, make_observer_dynamic(observer>(s))); + return s.get_subscriber(); } observable get_observable() const { - return make_observable_dynamic([this](subscriber o){ - this->s.add(std::move(o)); + auto keepAlive = s; + return make_observable_dynamic([=](subscriber o){ + keepAlive.add(s.get_subscriber(), std::move(o)); }); } }; diff --git a/Rx/v2/test/operators/lift.cpp b/Rx/v2/test/operators/lift.cpp index 7cf35b6..0496019 100644 --- a/Rx/v2/test/operators/lift.cpp +++ b/Rx/v2/test/operators/lift.cpp @@ -57,8 +57,8 @@ struct liftfilter dest.on_completed(); } - static rx::subscriber make(const dest_type& d, const test_type& t) { - return rx::make_subscriber(d, this_type(d, t)); + static rx::subscriber make(const dest_type& d, const test_type& t) { + return rx::make_subscriber(d, observer_type(this_type(d, t))); } }; @@ -120,7 +120,7 @@ SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]" auto res = w.start( [&xs, &invoked]() { return xs - .lift(liftfilter([&invoked](int x) { + .lift(liftfilter([&invoked](int x) { invoked++; return IsPrime(x); })) @@ -183,10 +183,10 @@ SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][stre auto res = w.start( [&xs, &invoked]() { return xs - >> liftfilter([&invoked](int x) { + >> rxo::lift(liftfilter([&invoked](int x) { invoked++; return IsPrime(x); - }) + })) // forget type to workaround lambda deduction bug on msvc 2013 >> rxo::as_dynamic(); }, @@ -250,7 +250,7 @@ SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][ return IsPrime(x); }; return xs - .lift([=](rx::subscriber dest){ + .lift([=](rx::subscriber dest){ // VS2013 deduction issue requires dynamic (type-forgetting) return rx::make_subscriber( dest, diff --git a/Rx/v2/test/sources/create.cpp b/Rx/v2/test/sources/create.cpp new file mode 100644 index 0000000..063ff7e --- /dev/null +++ b/Rx/v2/test/sources/create.cpp @@ -0,0 +1,46 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("create stops on completion", "[create][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + long invoked = 0; + + WHEN("created"){ + + auto res = w.start( + [&]() { + return rx::observable<>::create( + [&](const rx::subscriber& s){ + invoked++; + s.on_next(1); + s.on_next(2); + }) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains all items"){ + auto required = rxu::to_vector({ + on.on_next(200, 1), + on.on_next(200, 2) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("create was called until completed"){ + REQUIRE(1 == invoked); + } + } + } +} diff --git a/Rx/v2/test/sources/defer.cpp b/Rx/v2/test/sources/defer.cpp index bf4779e..e9e62c2 100644 --- a/Rx/v2/test/sources/defer.cpp +++ b/Rx/v2/test/sources/defer.cpp @@ -6,7 +6,7 @@ namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" -SCENARIO("defer stops on completion", "[defer][operators]"){ +SCENARIO("defer stops on completion", "[defer][sources]"){ GIVEN("a test cold observable of ints"){ auto sc = rxsc::make_test(); auto w = sc.create_worker(); diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp index 49d68e2..ae1a149 100644 --- a/Rx/v2/test/sources/interval.cpp +++ b/Rx/v2/test/sources/interval.cpp @@ -7,7 +7,7 @@ namespace rxsc=rxcpp::schedulers; #include "catch.hpp" -SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]"){ +SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf][sources]"){ GIVEN("schedule_periodically"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; @@ -29,7 +29,7 @@ SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf]") } } -SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][long][perf]"){ +SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][long][perf][sources]"){ GIVEN("schedule_periodically_duration"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; @@ -72,7 +72,7 @@ SCENARIO("schedule_periodically by duration", "[hide][periodically][scheduler][l } } -SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf]"){ +SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf][sources]"){ GIVEN("10 intervals of 1 seconds"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index b979c4f..6919b63 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -139,11 +139,11 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug std::atomic v(0); auto s0 = rxs::range(1, es) .take(values) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .as_dynamic() .publish_synchronized(es) .ref_count() - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( [&](int i){ @@ -154,11 +154,11 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug })); auto s1 = rxs::range(values + 1, es) .take(values) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .as_dynamic() .publish_synchronized(es) .ref_count() - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( [&](int i){ @@ -169,11 +169,11 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug })); auto s2 = rxs::range((values * 2) + 1, es) .take(values) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .as_dynamic() .publish_synchronized(es) .ref_count() - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( [&](int i){ @@ -249,10 +249,10 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o std::atomic v(0); auto s0 = rxs::range(1, es) .take(values) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .as_dynamic() .observe_on(es) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( [&](int i){ @@ -263,10 +263,10 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o })); auto s1 = rxs::range(values + 1, es) .take(values) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .as_dynamic() .observe_on(es) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( [&](int i){ @@ -277,10 +277,10 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o })); auto s2 = rxs::range((values * 2) + 1, es) .take(values) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .as_dynamic() .observe_on(es) - .lift(liftrequirecompletion) + .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( [&](int i){ diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 9e34654..3741630 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -33,6 +33,7 @@ set(TEST_SOURCES ${TEST_DIR}/subscriptions/observer.cpp ${TEST_DIR}/subscriptions/subscription.cpp ${TEST_DIR}/subjects/subject.cpp + ${TEST_DIR}/sources/create.cpp ${TEST_DIR}/sources/defer.cpp ${TEST_DIR}/sources/interval.cpp ${TEST_DIR}/operators/buffer.cpp -- GitLab From 667a8c86dc6c4e26026072bc48aec0a6d3d0531a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Jul 2014 11:12:31 -0700 Subject: [PATCH 392/782] print fixes --- Rx/v2/examples/println/main.cpp | 2 +- Rx/v2/src/rxcpp/rx-util.hpp | 31 ++++++++++++++++--------------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/Rx/v2/examples/println/main.cpp b/Rx/v2/examples/println/main.cpp index efe09ca..b9cf842 100644 --- a/Rx/v2/examples/println/main.cpp +++ b/Rx/v2/examples/println/main.cpp @@ -64,6 +64,6 @@ int main(int argc, char** argv) hello_tpl().subscribe(rxu::println(std::cout)); - hello_tpl().subscribe(rxu::print_delimited_by(std::cout, " and "), rxu::endline(std::cout)); + hello_tpl().subscribe(rxu::print_followed_by(std::cout, " and "), rxu::endline(std::cout)); return 0; } diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 9e613c4..ef8155a 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -313,6 +313,12 @@ struct insert_function } }; +template +auto print_followed_with(OStream& os, Delimit d) + -> detail::print_function { + return detail::print_function(os, std::move(d)); +} + } template @@ -321,25 +327,20 @@ auto endline(OStream& os) return detail::endline(os); } -template -auto print(OStream& os, Delimit d) - -> decltype(d(), detail::print_function(os, std::move(d))) { - return detail::print_function(os, std::move(d)); -} -template -auto print(OStream& os, Delimit d) - -> decltype(d(os), detail::print_function>(os, detail::insert_function(os, std::move(d)))) { - return detail::print_function>(os, detail::insert_function(os, std::move(d))); -} template auto println(OStream& os) - -> decltype(print(os, endline(os))) { - return print(os, endline(os)); + -> decltype(detail::print_followed_with(os, endline(os))) { + return detail::print_followed_with(os, endline(os)); +} +template +auto print_followed_with(OStream& os, Delimit d) + -> decltype(detail::print_followed_with(os, detail::insert_function(os, std::move(d)))) { + return detail::print_followed_with(os, detail::insert_function(os, std::move(d))); } template -auto print_delimited_by(OStream& os, DelimitValue dv) - -> detail::print_function> { - return detail::print_function>(os, detail::insert_value(os, std::move(dv))); +auto print_followed_by(OStream& os, DelimitValue dv) + -> decltype(detail::print_followed_with(os, detail::insert_value(os, std::move(dv)))) { + return detail::print_followed_with(os, detail::insert_value(os, std::move(dv))); } namespace detail { -- GitLab From 8c32cc2f2d74dde2da6113a9d58bc8527ad10e05 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Jul 2014 13:30:32 -0700 Subject: [PATCH 393/782] more lift fixes --- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 4 ++-- Rx/v2/src/rxcpp/operators/rx-map.hpp | 4 ++-- Rx/v2/src/rxcpp/rx-observable.hpp | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index ad2ec4f..08cd629 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -45,7 +45,7 @@ struct lift_traits }; template -struct lift : public operator_base::result_value_type> +struct lift_operator : public operator_base::result_value_type> { typedef lift_traits traits; typedef typename traits::source_operator_type source_operator_type; @@ -53,7 +53,7 @@ struct lift : public operator_base auto operator()(Observable&& source) - -> decltype(source.lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector))) { - return source.lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector)); + -> decltype(source.template lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector))) { + return source.template lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector)); } }; diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 944d230..103e4d9 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -307,9 +307,9 @@ public: /// template auto lift(Operator&& op) const - -> observable::value_type, rxo::detail::lift> { - return observable::value_type, rxo::detail::lift>( - rxo::detail::lift(source_operator, std::forward(op))); + -> observable::value_type, rxo::detail::lift_operator> { + return observable::value_type, rxo::detail::lift_operator>( + rxo::detail::lift_operator(source_operator, std::forward(op))); static_assert(detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); } -- GitLab From 6fdd6f9b945d9f9be48dc1d36ca199336a7ea081 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 29 Jul 2014 13:30:40 -0700 Subject: [PATCH 394/782] fix travis script --- projects/scripts/travis-install.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) mode change 100644 => 100755 projects/scripts/travis-install.sh diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh old mode 100644 new mode 100755 index 8fb05f2..3078b8a --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -26,5 +26,6 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then elif [ "$TRAVIS_OS_NAME" = osx ]; then xcode-select --install brew update - brew install cmake + brew doctor + brew list cmake || brew install cmake fi -- GitLab From 40ebdf2b474bc98e509734690f95c23dc92b3f05 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 30 Jul 2014 22:24:41 -0700 Subject: [PATCH 395/782] update catch library --- ext/catch | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/catch b/ext/catch index 8ba6555..6880a0c 160000 --- a/ext/catch +++ b/ext/catch @@ -1 +1 @@ -Subproject commit 8ba6555acd25da27cc9d8210119c0c57edac4704 +Subproject commit 6880a0c909778e9036b37ac4ddc601eee56b7b39 -- GitLab From fc4f3fa47e67e7b1d99dcec1a7092761426ab375 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 30 Jul 2014 22:31:03 -0700 Subject: [PATCH 396/782] add start_with --- Rx/v2/src/rxcpp/operators/rx-start_with.hpp | 24 +++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 23 ++++---------------- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + 3 files changed, 29 insertions(+), 19 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-start_with.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-start_with.hpp b/Rx/v2/src/rxcpp/operators/rx-start_with.hpp new file mode 100644 index 0000000..d605ceb --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-start_with.hpp @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_START_WITH_HPP) +#define RXCPP_OPERATORS_RX_START_WITH_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +template +auto start_with(Observable o, Value0 v0, ValueN... vn) + -> decltype(rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o)) { + return rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 103e4d9..8297014 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -884,32 +884,17 @@ public: return observable>( rxo::detail::repeat(*this, t)); } -#if 0 - -// causes infinite compile time recursion - - template - struct defer_start_with_from : public defer_observable< - rxu::all_true< - is_coordination::value, - std::is_convertible::value>, - this_type, - rxo::detail::concat, observable, observable>, Coordination> - { - }; /// start_with -> - /// All sources must be synchronized! This means that calls across all the subscribers must be serial. + /// start with the supplied values, then concatenate this observable /// /// template auto start_with(Value0 v0, ValueN... vn) const - -> typename std::enable_if< - defer_start_with_from::value, - typename defer_start_with_from::observable_type>::type { - return defer_start_with_from::make(*this, rxs::from(rxs::from(value_type(v0), value_type(vn)...).as_dynamic(), this->as_dynamic()), identity_immediate()); + -> decltype(rxo::start_with(*(this_type*)nullptr, std::move(v0), std::move(vn)...)) { + return rxo::start_with(*this, std::move(v0), std::move(vn)...); } -#endif + }; template diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 8ec9e74..1c43ff5 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -55,6 +55,7 @@ namespace rxo=operators; #include "operators/rx-scan.hpp" #include "operators/rx-skip.hpp" #include "operators/rx-skip_until.hpp" +#include "operators/rx-start_with.hpp" #include "operators/rx-subscribe.hpp" #include "operators/rx-subscribe_on.hpp" #include "operators/rx-switch_on_next.hpp" -- GitLab From 3bf429778a08eda9498c61ec1daa3664d5f1bbfd Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 2 Aug 2014 11:35:04 -0700 Subject: [PATCH 397/782] added group_by --- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 2 - Rx/v2/src/rxcpp/operators/rx-group_by.hpp | 220 ++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-grouped_observable.hpp | 203 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-includes.hpp | 1 + Rx/v2/src/rxcpp/rx-observable.hpp | 9 + Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/src/rxcpp/rx-predef.hpp | 37 ++++ Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 4 +- Rx/v2/test/operators/group_by.cpp | 112 +++++++++++ projects/CMake/CMakeLists.txt | 8 + 10 files changed, 594 insertions(+), 3 deletions(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-group_by.hpp create mode 100644 Rx/v2/src/rxcpp/rx-grouped_observable.hpp create mode 100644 Rx/v2/test/operators/group_by.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 84aeb66..f8fd1d7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -32,9 +32,7 @@ struct flat_map_traits { typedef decltype((*(collection_selector_type*)nullptr)((*(source_value_type*)nullptr))) collection_type; -//#if _MSC_VER >= 1900 static_assert(is_observable::value, "flat_map CollectionSelector must return an observable"); -//#endif typedef typename collection_type::value_type collection_value_type; diff --git a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp new file mode 100644 index 0000000..3982e8b --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp @@ -0,0 +1,220 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_GROUP_BY_HPP) +#define RXCPP_OPERATORS_RX_GROUP_BY_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct is_group_by_selector_for { + + typedef typename std::decay::type selector_type; + typedef T source_value_type; + + struct tag_not_valid {}; + template + static auto check(int) -> decltype((*(CS*)nullptr)(*(CV*)nullptr)); + template + static tag_not_valid check(...); + + typedef decltype(check(0)) type; + static const bool value = !std::is_same::value; +}; + +template +struct group_by_traits +{ + typedef T source_value_type; + typedef typename std::decay::type source_type; + typedef typename std::decay::type key_selector_type; + typedef typename std::decay::type marble_selector_type; + typedef typename std::decay::type predicate_type; + + static_assert(is_group_by_selector_for::value, "group_by KeySelector must be a function with the signature key_type(source_value_type)"); + + typedef typename is_group_by_selector_for::type key_type; + + static_assert(is_group_by_selector_for::value, "group_by MarbleSelector must be a function with the signature marble_type(source_value_type)"); + + typedef typename is_group_by_selector_for::type marble_type; + + typedef rxsub::subject subject_type; + + typedef std::map key_subscriber_map_type; + + typedef grouped_observable grouped_observable_type; +}; + +template +struct group_by +{ + typedef group_by_traits traits_type; + typedef typename traits_type::key_selector_type key_selector_type; + typedef typename traits_type::marble_selector_type marble_selector_type; + typedef typename traits_type::predicate_type predicate_type; + typedef typename traits_type::subject_type subject_type; + typedef typename traits_type::key_type key_type; + + struct group_by_values + { + group_by_values(key_selector_type ks, marble_selector_type ms, predicate_type p) + : keySelector(std::move(ks)) + , marbleSelector(std::move(ms)) + , predicate(std::move(p)) + { + } + mutable key_selector_type keySelector; + mutable marble_selector_type marbleSelector; + mutable predicate_type predicate; + }; + + group_by_values initial; + + group_by(key_selector_type ks, marble_selector_type ms, predicate_type p) + : initial(std::move(ks), std::move(ms), std::move(p)) + { + } + + struct group_by_observable + { + subject_type subject; + key_type key; + + group_by_observable(subject_type s, key_type k) + : subject(std::move(s)) + , key(k) + { + } + + template + void on_subscribe(Subscriber&& o) const { + subject.get_observable().subscribe(std::forward(o)); + } + + key_type on_get_key() { + return key; + } + }; + + template + struct group_by_observer : public group_by_values + { + typedef group_by_observer this_type; + typedef typename traits_type::grouped_observable_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + + mutable typename traits_type::key_subscriber_map_type groups; + + group_by_observer(dest_type d, group_by_values v) + : group_by_values(v) + , dest(std::move(d)) + , groups(group_by_values::predicate) + { + } + void on_next(T v) const { + auto selectedKey = on_exception( + [&](){ + return this->keySelector(v);}, + *this); + if (selectedKey.empty()) { + return; + } + auto g = groups.find(selectedKey.get()); + if (g == groups.end()) { + auto sub = subject_type(); + g = groups.insert(std::make_pair(selectedKey.get(), sub.get_subscriber())).first; + dest.on_next(make_dynamic_grouped_observable(group_by_observable(sub, selectedKey.get()))); + } + auto selectedMarble = on_exception( + [&](){ + return this->marbleSelector(v);}, + *this); + if (selectedMarble.empty()) { + return; + } + g->second.on_next(std::move(selectedMarble.get())); + } + void on_error(std::exception_ptr e) const { + (*this)(e); + } + void operator()(std::exception_ptr e) const { + for(auto& g : groups) { + g.second.on_error(e); + } + dest.on_error(e); + } + void on_completed() const { + for(auto& g : groups) { + g.second.on_completed(); + } + dest.on_completed(); + } + + static subscriber make(dest_type d, group_by_values v) { + auto cs = d.get_subscription(); + return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(v)))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(group_by_observer::make(std::move(dest), initial)) { + return group_by_observer::make(std::move(dest), initial); + } +}; + +template +class group_by_factory +{ + typedef typename std::decay::type key_selector_type; + typedef typename std::decay::type marble_selector_type; + typedef typename std::decay::type predicate_type; + key_selector_type keySelector; + marble_selector_type marbleSelector; + predicate_type predicate; +public: + group_by_factory(key_selector_type ks, marble_selector_type ms, predicate_type p) + : keySelector(std::move(ks)) + , marbleSelector(std::move(ms)) + , predicate(std::move(p)) + { + } + template + struct group_by_factory_traits + { + typedef typename Observable::value_type value_type; + typedef detail::group_by_traits traits_type; + typedef detail::group_by group_by_type; + }; + template + auto operator()(Observable&& source) + -> decltype(source.template lift::traits_type::grouped_observable_type>(typename group_by_factory_traits::group_by_type(std::move(keySelector), std::move(marbleSelector), std::move(predicate)))) { + return source.template lift::traits_type::grouped_observable_type>(typename group_by_factory_traits::group_by_type(std::move(keySelector), std::move(marbleSelector), std::move(predicate))); + } +}; + +} + +template +inline auto group_by(KeySelector ks, MarbleSelector ms, BinaryPredicate p) + -> detail::group_by_factory { + return detail::group_by_factory(std::move(ks), std::move(ms), std::move(p)); +} + + +} + +} + +#endif + diff --git a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp new file mode 100644 index 0000000..8dca40b --- /dev/null +++ b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp @@ -0,0 +1,203 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_RX_GROUPED_OBSERVABLE_HPP) +#define RXCPP_RX_GROUPED_OBSERVABLE_HPP + +#include "rx-includes.hpp" + +namespace rxcpp { + +namespace detail { + +template +struct has_on_get_key_for +{ + struct not_void {}; + template + static auto check(int) -> decltype((*(CS*)nullptr).on_get_key()); + template + static not_void check(...); + + typedef decltype(check(0)) detail_result; + static const bool value = std::is_same::type>::value; +}; + +} + +template +class dynamic_grouped_observable + : public rxs::source_base +{ +public: + typedef typename std::decay::type key_type; + typedef tag_dynamic_observable dynamic_observable_tag; + +private: + struct state_type + : public std::enable_shared_from_this + { + typedef std::function)> onsubscribe_type; + typedef std::function ongetkey_type; + + onsubscribe_type on_subscribe; + ongetkey_type on_get_key; + }; + std::shared_ptr state; + + template + void construct(const dynamic_observable& o, tag_dynamic_observable&&) { + state = o.state; + } + + template + void construct(dynamic_observable&& o, tag_dynamic_observable&&) { + state = std::move(o.state); + } + + template + void construct(SO&& source, rxs::tag_source&&) { + auto so = std::make_shared::type>(std::forward(source)); + state->on_subscribe = [so](subscriber o) mutable { + so->on_subscribe(std::move(o)); + }; + state->on_get_key = [so]() mutable { + return so->on_get_key(); + }; + } + +public: + + dynamic_grouped_observable() + { + } + + template + explicit dynamic_grouped_observable(SOF&& sof) + : state(std::make_shared()) + { + construct(std::forward(sof), + typename std::conditional::value, tag_dynamic_observable, rxs::tag_source>::type()); + } + + template + dynamic_grouped_observable(SF&& sf, CF&& cf) + : state(std::make_shared()) + { + state->on_subscribe = std::forward(sf); + state->on_connect = std::forward(cf); + } + + void on_subscribe(subscriber o) const { + state->on_subscribe(std::move(o)); + } + + template + typename std::enable_if::type, observer>::value, void>::type + on_subscribe(Subscriber&& o) const { + auto so = std::make_shared::type>(std::forward(o)); + state->on_subscribe( + make_subscriber( + *so, + // on_next + [so](T t){ + so->on_next(t); + }, + // on_error + [so](std::exception_ptr e){ + so->on_error(e); + }, + // on_completed + [so](){ + so->on_completed(); + }). + as_dynamic()); + } + + key_type on_get_key() const { + return state->on_get_key(); + } +}; + +template +grouped_observable make_dynamic_grouped_observable(Source&& s) { + return grouped_observable(dynamic_grouped_observable(std::forward(s))); +} + + + +template +class grouped_observable + : public observable +{ + typedef grouped_observable this_type; + typedef observable base_type; + typedef typename std::decay::type source_operator_type; + + static_assert(detail::has_on_get_key_for::value, "inner must have on_get_key method key_type()"); + +public: + typedef typename std::decay::type key_type; + typedef tag_grouped_observable observable_tag; + + grouped_observable() + { + } + + explicit grouped_observable(const SourceOperator& o) + : base_type(o) + { + } + explicit grouped_observable(SourceOperator&& o) + : base_type(std::move(o)) + { + } + + // implicit conversion between observables of the same value_type + template + grouped_observable(const grouped_observable& o) + : base_type(o) + {} + // implicit conversion between observables of the same value_type + template + grouped_observable(grouped_observable&& o) + : base_type(std::move(o)) + {} + + /// + /// performs type-forgetting conversion to a new grouped_observable + /// + grouped_observable as_dynamic() const { + return *this; + } + + key_type get_key() const { + return base_type::source_operator.on_get_key(); + } +}; + + +} + +// +// support range() >> filter() >> subscribe() syntax +// '>>' is spelled 'stream' +// +template +auto operator >> (const rxcpp::grouped_observable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); +} + +// +// support range() | filter() | subscribe() syntax +// '|' is spelled 'pipe' +// +template +auto operator | (const rxcpp::grouped_observable& source, OperatorFactory&& of) + -> decltype(source.op(std::forward(of))) { + return source.op(std::forward(of)); +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 86fd34a..5ca50e1 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -132,6 +132,7 @@ #include "rx-operators.hpp" #include "rx-observable.hpp" #include "rx-connectable_observable.hpp" +#include "rx-grouped_observable.hpp" #pragma pop_macro("min") #pragma pop_macro("max") diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 8297014..c93d408 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -662,6 +662,15 @@ public: return defer_combine_latest::make(*this, std::move(cn), rxu::pack(), std::make_tuple(*this, on...)); } + /// group_by -> + /// + template + inline auto group_by(KeySelector ks, MarbleSelector ms, BinaryPredicate p) const + -> decltype(EXPLICIT_THIS lift::grouped_observable_type>(rxo::detail::group_by(std::move(ks), std::move(ms), std::move(p)))) { + return lift::grouped_observable_type>(rxo::detail::group_by(std::move(ks), std::move(ms), std::move(p))); + } + + /// multicast -> /// allows connections to the source to be independent of subscriptions /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 1c43ff5..b62ddd6 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -43,6 +43,7 @@ namespace rxo=operators; #include "operators/rx-filter.hpp" #include "operators/rx-finally.hpp" #include "operators/rx-flat_map.hpp" +#include "operators/rx-group_by.hpp" #include "operators/rx-lift.hpp" #include "operators/rx-map.hpp" #include "operators/rx-merge.hpp" diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 1b82f40..bd94151 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -194,6 +194,43 @@ public: static const bool value = std::is_convertible::type>(0)), tag_connectable_observable>::value; }; +struct tag_dynamic_grouped_observable : public tag_dynamic_observable {}; + +template +class is_dynamic_grouped_observable +{ + struct not_void {}; + template + static typename C::dynamic_observable_tag* check(int); + template + static not_void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_dynamic_grouped_observable*>::value; +}; + +template +class dynamic_grouped_observable; + +template::value, + void, dynamic_grouped_observable>::type> +class grouped_observable; + +template +grouped_observable make_dynamic_grouped_observable(Source&& s); + +struct tag_grouped_observable : public tag_observable {}; +template +class is_grouped_observable +{ + template + static typename C::observable_tag check(int); + template + static void check(...); +public: + static const bool value = std::is_convertible::type>(0)), tag_grouped_observable>::value; +}; + // // this type is the default used by operators that subscribe to // multiple sources. It assumes that the sources are already synchronized diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index e07cc69..4ead228 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -214,6 +214,8 @@ class subject detail::multicast_observer s; public: + typedef subscriber>> subscriber_type; + typedef observable observable_type; subject() : s(composite_subscription()) { @@ -227,7 +229,7 @@ public: return s.has_observers(); } - subscriber>> get_subscriber() const { + subscriber_type get_subscriber() const { return s.get_subscriber(); } diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp new file mode 100644 index 0000000..30e06ec --- /dev/null +++ b/Rx/v2/test/operators/group_by.cpp @@ -0,0 +1,112 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxs=rxcpp::sources; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +char whitespace(char c) { + return std::isspace(c) || std::iscntrl(c); +} + +std::string trim(std::string s) { + auto first = std::find_if_not(s.begin(), s.end(), whitespace); + auto last = std::find_if_not(s.rbegin(), s.rend(), whitespace); + if (last != s.rend()) { + s.erase(s.end() - (last-s.rbegin()), s.end()); + } + s.erase(s.begin(), first); + return std::move(s); +} + +bool tolowerLess(char lhs, char rhs) { + return std::tolower(lhs) < std::tolower(rhs); +} + +bool tolowerStringLess(const std::string& lhs, const std::string& rhs) { + return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), tolowerLess); +} + +SCENARIO("group_by", "[group_by][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + int keyInvoked = 0; + int marbleInvoked = 0; + + auto xs = sc.make_hot_observable({ + on.on_next(90, "error"), + on.on_next(110, "error"), + on.on_next(130, "error"), + on.on_next(220, " foo"), + on.on_next(240, " FoO "), + on.on_next(270, "baR "), + on.on_next(310, "foO "), + on.on_next(350, " Baz "), + on.on_next(360, " qux "), + on.on_next(390, " bar"), + on.on_next(420, " BAR "), + on.on_next(470, "FOO "), + on.on_next(480, "baz "), + on.on_next(510, " bAZ "), + on.on_next(530, " fOo "), + on.on_completed(570), + on.on_next(580, "error"), + on.on_completed(600), + on.on_error(650, new std::runtime_error("error in completed sequence")) + }); + + WHEN("group each int with the next 2 ints"){ + + auto res = w.start( + [&]() { + return xs + .group_by( + [&](std::string v){ + ++keyInvoked; + return trim(std::move(v)); + }, + [&](std::string v){ + ++marbleInvoked; + std::reverse(v.begin(), v.end()); + return v; + }, + tolowerStringLess) + .map([](const rxcpp::grouped_observable& g){return g.get_key();}) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + on.on_next(220, "foo"), + on.on_next(270, "baR"), + on.on_next(350, "Baz"), + on.on_next(360, "qux"), + on.on_completed(570) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 570) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("key selector was invoked for each value"){ + REQUIRE(12 == keyInvoked); + } + + THEN("marble selector was invoked for each value"){ + REQUIRE(12 == marbleInvoked); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 3741630..99c20f2 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -44,6 +44,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/distinct_until_changed.cpp ${TEST_DIR}/operators/filter.cpp ${TEST_DIR}/operators/flat_map.cpp + ${TEST_DIR}/operators/group_by.cpp ${TEST_DIR}/operators/lift.cpp ${TEST_DIR}/operators/map.cpp ${TEST_DIR}/operators/merge.cpp @@ -63,6 +64,13 @@ set(TEST_SOURCES add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) +set(OP_SOURCES + ${TEST_DIR}/test.cpp + ${TEST_DIR}/operators/group_by.cpp +) +#add_executable(op_test ${OP_SOURCES}) +#TARGET_LINK_LIBRARIES(op_test ${CMAKE_THREAD_LIBS_INIT}) + set(EXAMPLES_DIR ${RXCPP_DIR}/Rx/v2/examples) # define the sources of the pythagorian example -- GitLab From 69bf799b3f11d4f5ceebf1984a613efc91552e69 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 2 Aug 2014 22:48:47 -0700 Subject: [PATCH 398/782] alternative error propagation --- Rx/v2/src/rxcpp/operators/rx-group_by.hpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp index 3982e8b..726d2da 100644 --- a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp @@ -125,7 +125,7 @@ struct group_by auto selectedKey = on_exception( [&](){ return this->keySelector(v);}, - *this); + [this](std::exception_ptr e){on_error(e);}); if (selectedKey.empty()) { return; } @@ -138,16 +138,13 @@ struct group_by auto selectedMarble = on_exception( [&](){ return this->marbleSelector(v);}, - *this); + [this](std::exception_ptr e){on_error(e);}); if (selectedMarble.empty()) { return; } g->second.on_next(std::move(selectedMarble.get())); } void on_error(std::exception_ptr e) const { - (*this)(e); - } - void operator()(std::exception_ptr e) const { for(auto& g : groups) { g.second.on_error(e); } -- GitLab From 206955e96e184f99c7a4c7002ae6f0af6b469a3c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 2 Aug 2014 23:45:19 -0700 Subject: [PATCH 399/782] fix travis failure, move to clang 3.6 --- projects/scripts/travis-install.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 3078b8a..8f9f5fe 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -14,7 +14,7 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then sudo apt-get install -q --fix-missing cmake libssl-dev if [ "$CC" = clang ]; then - sudo apt-get install -q --fix-missing clang-3.5 + sudo apt-get install -q --fix-missing clang-3.6 fi if [ "$CC" = gcc ]; then -- GitLab From 479f737e1a9fb77ae26eb14455da263d76e9bfd8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 3 Aug 2014 00:06:38 -0700 Subject: [PATCH 400/782] change tolower and isspace to use classic locale --- Rx/v2/test/operators/group_by.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index 30e06ec..4e81245 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -7,7 +7,7 @@ namespace rxsc=rxcpp::schedulers; #include "catch.hpp" char whitespace(char c) { - return std::isspace(c) || std::iscntrl(c); + return std::isspace(c, std::locale::classic()); } std::string trim(std::string s) { @@ -21,7 +21,7 @@ std::string trim(std::string s) { } bool tolowerLess(char lhs, char rhs) { - return std::tolower(lhs) < std::tolower(rhs); + return std::tolower(lhs, std::locale::classic()) < std::tolower(rhs, std::locale::classic()); } bool tolowerStringLess(const std::string& lhs, const std::string& rhs) { -- GitLab From 66985d48eb67976256d4758fdf0a9fe836664c0a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sun, 3 Aug 2014 00:35:29 -0700 Subject: [PATCH 401/782] msvc 2013 fixes --- Rx/v2/src/rxcpp/rx-grouped_observable.hpp | 14 +++++++------- Rx/v2/test/operators/group_by.cpp | 2 ++ 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp index 8dca40b..a56878c 100644 --- a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp @@ -32,7 +32,7 @@ class dynamic_grouped_observable { public: typedef typename std::decay::type key_type; - typedef tag_dynamic_observable dynamic_observable_tag; + typedef tag_dynamic_grouped_observable dynamic_observable_tag; private: struct state_type @@ -46,18 +46,18 @@ private: }; std::shared_ptr state; - template - void construct(const dynamic_observable& o, tag_dynamic_observable&&) { + template + void construct(const dynamic_grouped_observable& o, const tag_dynamic_grouped_observable&) { state = o.state; } - template - void construct(dynamic_observable&& o, tag_dynamic_observable&&) { + template + void construct(dynamic_grouped_observable&& o, const tag_dynamic_grouped_observable&) { state = std::move(o.state); } template - void construct(SO&& source, rxs::tag_source&&) { + void construct(SO&& source, const rxs::tag_source&) { auto so = std::make_shared::type>(std::forward(source)); state->on_subscribe = [so](subscriber o) mutable { so->on_subscribe(std::move(o)); @@ -78,7 +78,7 @@ public: : state(std::make_shared()) { construct(std::forward(sof), - typename std::conditional::value, tag_dynamic_observable, rxs::tag_source>::type()); + typename std::conditional::value, tag_dynamic_grouped_observable, rxs::tag_source>::type()); } template diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index 4e81245..ac1b8cc 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -6,6 +6,8 @@ namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" +#include + char whitespace(char c) { return std::isspace(c, std::locale::classic()); } -- GitLab From c12bb8ffb1167ddd5ef11fb31586357f4a893dff Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 4 Aug 2014 08:16:15 -0700 Subject: [PATCH 402/782] add blocking_observable and last, count operators --- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 35 ++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 108 +++++++++++++++++++++++- Rx/v2/src/rxcpp/rx-util.hpp | 9 ++ Rx/v2/test/operators/concat.cpp | 51 ++--------- Rx/v2/test/operators/concat_map.cpp | 67 ++------------- Rx/v2/test/operators/flat_map.cpp | 51 ++--------- Rx/v2/test/operators/merge.cpp | 54 ++---------- 7 files changed, 186 insertions(+), 189 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index c70f7bd..043566e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -180,6 +180,35 @@ struct initialize_seeder { } }; +template +struct last { + typedef rxu::maybe::type> seed_type; + seed_type seed() { + return seed_type{}; + } + seed_type operator()(const seed_type& a, T v) { + return seed_type(v); + } + typename std::decay::type operator()(seed_type a) { + // should abort if a is empty + return a.get(); + } +}; + +template +struct count { + typedef int seed_type; + seed_type seed() { + return seed_type{}; + } + seed_type operator()(seed_type a, T v) { + return ++a; + } + seed_type operator()(seed_type a) { + return a; + } +}; + template struct average { struct seed_type @@ -232,6 +261,12 @@ struct average { } +template +auto first(Observable o) + -> decltype(o.take(1).last()) { + return o.take(1).last(); +} + template auto reduce(Seed s, Accumulator a, ResultSelector rs) -> detail::reduce_factory { diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index c93d408..0a72748 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -175,6 +175,72 @@ struct defer_observable { }; +template +class blocking_observable +{ + template + static auto blocking_subscribe(const Obsvbl& source, ArgN&&... an) + -> composite_subscription { + std::mutex lock; + std::condition_variable wake; + std::atomic_bool disposed; + auto scbr = make_subscriber(std::forward(an)...); + auto cs = scbr.get_subscription(); + cs.add([&](){ + disposed = true; + wake.notify_one(); + }); + std::unique_lock guard(lock); + source.subscribe(scbr); + wake.wait(guard, [&](){return !!disposed;}); + return cs; + } + +public: + typedef typename std::decay::type observable_type; + observable_type source; + blocking_observable(observable_type s) : source(std::move(s)) {} + + /// + /// subscribe will cause this observable to emit values to the provided subscriber. + /// callers must provide enough arguments to make a subscriber. + /// overrides are supported. thus + /// subscribe(thesubscriber, composite_subscription()) + /// will take thesubscriber.get_observer() and the provided + /// subscription and subscribe to the new subscriber. + /// the on_next, on_error, on_completed methods can be supplied instead of an observer + /// if a subscription or subscriber is not provided then a new subscription will be created. + /// + template + auto subscribe(ArgN&&... an) const + -> composite_subscription { + return blocking_subscribe(source, std::forward(an)...); + } + + T first() { + rxu::maybe result; + composite_subscription cs; + subscribe(cs, [&](T v){result.reset(v); cs.unsubscribe();}); + return result.get(); + } + + T last() const { + rxu::maybe result; + subscribe([&](T v){result.reset(v);}); + return result.get(); + } + + int count() const { + return source.count().as_blocking().last(); + } + T sum() const { + return source.sum().as_blocking().last(); + } + double average() const { + return source.average().as_blocking().last(); + } +}; + template<> class observable; @@ -282,12 +348,19 @@ public: #endif /// - /// performs type-forgetting conversion to a new observable + /// returns a new observable that performs type-forgetting conversion of this observable /// observable as_dynamic() const { return *this; } + /// + /// returns new observable that contains the blocking methods for this observable + /// + blocking_observable as_blocking() const { + return blocking_observable(*this); + } + /// /// takes any function that will take this observable and produce a result value. /// this is intended to allow externally defined operators, that use subscribe, @@ -670,6 +743,13 @@ public: return lift::grouped_observable_type>(rxo::detail::group_by(std::move(ks), std::move(ms), std::move(p))); } + /// group_by -> + /// + template + inline auto group_by(KeySelector ks, MarbleSelector ms) const + -> decltype(EXPLICIT_THIS lift::grouped_observable_type>(rxo::detail::group_by(std::move(ks), std::move(ms), rxu::less()))) { + return lift::grouped_observable_type>(rxo::detail::group_by(std::move(ks), std::move(ms), rxu::less())); + } /// multicast -> /// allows connections to the source to be independent of subscriptions @@ -748,8 +828,32 @@ public: { }; + /// first -> + /// for each item from this observable reduce it by sending only the first item. + /// +// auto first() const +// -> decltype(rxo::first(*(this_type*)nullptr)) { +// return rxo::first(*this); +// } + + /// last -> + /// for each item from this observable reduce it by sending only the last item. + /// + auto last() const + -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { + return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, rxo::detail::last(), rxo::detail::last(), rxo::detail::last().seed()); + } + + /// count -> + /// for each item from this observable reduce it by incrementing a count. + /// + auto count() const + -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { + return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, rxo::detail::count(), rxo::detail::count(), rxo::detail::count().seed()); + } + /// sum -> - /// for each item from this observable reduce it by adding to the previous values. + /// for each item from this observable reduce it by adding to the previous items. /// auto sum() const -> typename defer_reduce, rxu::plus, rxu::defer_type>::observable_type { diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index ef8155a..470b532 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -261,6 +261,14 @@ struct plus { return std::forward(lhs) + std::forward(rhs); } }; +struct less +{ + template + auto operator()(LHS&& lhs, RHS&& rhs) const + -> decltype(std::forward(lhs) < std::forward(rhs)) + { return std::forward(lhs) < std::forward(rhs); } +}; + namespace detail { template struct print_function @@ -471,6 +479,7 @@ public: }; } +using detail::maybe; namespace detail { struct surely diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index e4c23b7..91be2be 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -16,29 +16,18 @@ SCENARIO("synchronize concat ranges", "[hide][range][synchronize][concat][perf]" using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::synchronize_event_loop(); - std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, so) + auto c = rxs::range(0, sectionCount - 1, 1, so) .concat( so, rxs::range(sectionCount, sectionCount * 2 - 1, 1, so), rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) - .subscribe( - [&c](int x){ - ++c;}, - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return c == onnextcalls;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -55,29 +44,18 @@ SCENARIO("observe_on concat ranges", "[hide][range][observe_on][concat][perf]"){ using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::observe_on_event_loop(); - std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, so) + int c = rxs::range(0, sectionCount - 1, 1, so) .concat( so, rxs::range(sectionCount, sectionCount * 2 - 1, 1, so), rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) - .subscribe( - [&c](int x){ - ++c;}, - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return c == onnextcalls;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -94,29 +72,18 @@ SCENARIO("serialize concat ranges", "[hide][range][serialize][concat][perf]"){ using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::serialize_event_loop(); - std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, so) + int c = rxs::range(0, sectionCount - 1, 1, so) .concat( so, rxs::range(sectionCount, sectionCount * 2 - 1, 1, so), rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) - .subscribe( - [&c](int x){ - ++c;}, - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return c == onnextcalls;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 2787089..7dc1302 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -61,13 +61,9 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::synchronize_event_loop(); int c = 0; - std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -93,17 +89,10 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}, so); - triples + int ct = triples .take(tripletCount) - .subscribe( - rxu::apply_to([&ct](int x,int y,int z){ - ++ct;}), - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -120,15 +109,9 @@ SCENARIO("observe_on concat_map pythagorian ranges", "[hide][range][concat_map][ using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::observe_on_event_loop(); int c = 0; - std::atomic_bool done; - std::atomic_bool disposed; - std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -155,23 +138,10 @@ SCENARIO("observe_on concat_map pythagorian ranges", "[hide][range][concat_map][ [](int z, std::tuple triplet){return triplet;}, so); - rx::composite_subscription cs; - cs.add([&](){ - disposed = true; - wake.notify_one();}); - - triples + int ct = triples .take(tripletCount) - .subscribe( - cs, - rxu::apply_to([&ct](int x,int y,int z){ - ++ct;}), - [&](){ - done = true; - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount && done && disposed;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -188,15 +158,9 @@ SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][s using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::serialize_event_loop(); int c = 0; - std::atomic_bool done; - std::atomic_bool disposed; - std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -223,23 +187,10 @@ SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][s [](int z, std::tuple triplet){return triplet;}, so); - rx::composite_subscription cs; - cs.add([&](){ - disposed = true; - wake.notify_one();}); - - triples + int ct = triples .take(tripletCount) - .subscribe( - cs, - rxu::apply_to([&ct](int x,int y,int z){ - ++ct;}), - [&](){ - done = true; - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount && done && disposed;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index d32de54..9f99055 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -97,13 +97,9 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::synchronize_event_loop(); int c = 0; - std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -129,17 +125,10 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}, so); - triples + int ct = triples .take(tripletCount) - .subscribe( - rxu::apply_to([&ct](int x,int y,int z){ - ++ct;}), - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -156,13 +145,9 @@ SCENARIO("observe_on flat_map pythagorian ranges", "[hide][range][flat_map][obse using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::observe_on_event_loop(); int c = 0; - std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -188,17 +173,10 @@ SCENARIO("observe_on flat_map pythagorian ranges", "[hide][range][flat_map][obse .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}, so); - triples + int ct = triples .take(tripletCount) - .subscribe( - rxu::apply_to([&ct](int x,int y,int z){ - ++ct;}), - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -215,13 +193,9 @@ SCENARIO("serialize flat_map pythagorian ranges", "[hide][range][flat_map][seria using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::serialize_event_loop(); int c = 0; - std::atomic ct(0); int n = 1; auto start = clock::now(); auto triples = @@ -247,17 +221,10 @@ SCENARIO("serialize flat_map pythagorian ranges", "[hide][range][flat_map][seria .as_dynamic();}, [](int z, std::tuple triplet){return triplet;}, so); - triples + int ct = triples .take(tripletCount) - .subscribe( - rxu::apply_to([&ct](int x,int y,int z){ - ++ct;}), - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one();}); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return ct == tripletCount;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index a964b0e..a8a32ad 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -17,30 +17,18 @@ SCENARIO("synchronize merge ranges", "[hide][range][synchronize][merge][perf]"){ using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::synchronize_event_loop(); - std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, so) + int c = rxs::range(0, sectionCount - 1, 1, so) .merge( so, rxs::range(sectionCount, (sectionCount * 2) - 1, 1, so), rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) - .subscribe( - [&c](int x){ - ++c;}, - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one(); - }); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return c == onnextcalls;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -57,30 +45,18 @@ SCENARIO("observe_on merge ranges", "[hide][range][observe_on][merge][perf]"){ using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::observe_on_event_loop(); - std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, so) + int c = rxs::range(0, sectionCount - 1, 1, so) .merge( so, rxs::range(sectionCount, (sectionCount * 2) - 1, 1, so), rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) - .subscribe( - [&c](int x){ - ++c;}, - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one(); - }); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return c == onnextcalls;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -97,30 +73,18 @@ SCENARIO("serialize merge ranges", "[hide][range][serialize][merge][perf]"){ using namespace std::chrono; typedef steady_clock clock; - std::mutex lock; - std::condition_variable wake; - auto so = rx::serialize_event_loop(); - std::atomic c(0); int n = 1; auto sectionCount = onnextcalls / 3; auto start = clock::now(); - rxs::range(0, sectionCount - 1, 1, so) + int c = rxs::range(0, sectionCount - 1, 1, so) .merge( so, rxs::range(sectionCount, (sectionCount * 2) - 1, 1, so), rxs::range(sectionCount * 2, onnextcalls - 1, 1, so)) - .subscribe( - [&c](int x){ - ++c;}, - [](std::exception_ptr){abort();}, - [&](){ - wake.notify_one(); - }); - - std::unique_lock guard(lock); - wake.wait(guard, [&](){return c == onnextcalls;}); + .as_blocking() + .count(); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - -- GitLab From 6ca3b3ef1321e6a938ac95b9736b5993e4cc7232 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 5 Aug 2014 16:12:47 -0700 Subject: [PATCH 403/782] add first --- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 6 ------ Rx/v2/src/rxcpp/rx-observable.hpp | 13 +++++++++---- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 043566e..0baa827 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -261,12 +261,6 @@ struct average { } -template -auto first(Observable o) - -> decltype(o.take(1).last()) { - return o.take(1).last(); -} - template auto reduce(Seed s, Accumulator a, ResultSelector rs) -> detail::reduce_factory { diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 0a72748..b8c6a1a 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -831,10 +831,8 @@ public: /// first -> /// for each item from this observable reduce it by sending only the first item. /// -// auto first() const -// -> decltype(rxo::first(*(this_type*)nullptr)) { -// return rxo::first(*this); -// } + auto first() const + -> observable; /// last -> /// for each item from this observable reduce it by sending only the last item. @@ -1010,6 +1008,13 @@ public: }; +template +auto observable::first() const + -> observable { + return this->take(1).last(); +} + + template inline bool operator==(const observable& lhs, const observable& rhs) { return lhs.source_operator == rhs.source_operator; -- GitLab From 40c270e5409f9911c5e286b85ff7db5df62d9701 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 5 Aug 2014 16:13:02 -0700 Subject: [PATCH 404/782] ignore sublime projects --- .gitignore | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.gitignore b/.gitignore index 6fe9162..73574ce 100644 --- a/.gitignore +++ b/.gitignore @@ -108,3 +108,9 @@ Desktop.ini projects/* !projects/CMake/CMakeLists.txt !projects/nuget/rxcpp.autopackage + +############ +## Sublime +############ + +*.sublime-* -- GitLab From 4e693790b7aaa46bde9a20c90addaefbf46c34c8 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 9 Aug 2014 17:03:30 -0700 Subject: [PATCH 405/782] minor fixes --- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 7 +-- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 8 ++- Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp | 41 ++++++++----- Rx/v2/test/operators/subscribe_on.cpp | 60 +++++++++++++++---- 4 files changed, 83 insertions(+), 33 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index c1157de..4d89044 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -167,13 +167,10 @@ struct observe_on auto keepAlive = o.state; cs.add([keepAlive](){ std::unique_lock guard(keepAlive->lock); - if (keepAlive->queue.empty() && keepAlive->current == mode::Empty && keepAlive->destination.is_subscribed()) { - keepAlive->current = mode::Disposed; - keepAlive->destination.unsubscribe(); - } + keepAlive->ensure_processing(guard); }); - return make_subscriber(cs, std::move(o)); + return make_subscriber(d, cs, make_observer(std::move(o))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 0baa827..e53f2c5 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -80,6 +80,9 @@ struct reduce : public operator_base - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { struct reduce_state_type : public reduce_initial_type , public std::enable_shared_from_this diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp index 3899b19..e62e8ff 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp @@ -19,9 +19,12 @@ struct subscribe_on : public operator_base typedef typename std::decay::type source_type; typedef typename std::decay::type coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - struct values + struct subscribe_on_values { - values(source_type s, coordination_type sf) + ~subscribe_on_values() + { + } + subscribe_on_values(source_type s, coordination_type sf) : source(std::move(s)) , coordination(std::move(sf)) { @@ -29,8 +32,11 @@ struct subscribe_on : public operator_base source_type source; coordination_type coordination; }; - values initial; + const subscribe_on_values initial; + ~subscribe_on() + { + } subscribe_on(source_type s, coordination_type sf) : initial(std::move(s), std::move(sf)) { @@ -42,10 +48,10 @@ struct subscribe_on : public operator_base typedef Subscriber output_type; struct subscribe_on_state_type : public std::enable_shared_from_this - , public values + , public subscribe_on_values { - subscribe_on_state_type(const values& i, coordinator_type coor, const output_type& oarg) - : values(i) + subscribe_on_state_type(const subscribe_on_values& i, coordinator_type coor, const output_type& oarg) + : subscribe_on_values(i) , coordinator(std::move(coor)) , out(oarg) { @@ -62,16 +68,21 @@ struct subscribe_on : public operator_base // take a copy of the values for each subscription auto state = std::shared_ptr(new subscribe_on_state_type(initial, std::move(coordinator), std::move(s))); + auto disposer = [=](const rxsc::schedulable&){ + state->source_lifetime.unsubscribe(); + state->out.unsubscribe(); + }; + auto selectedDisposer = on_exception( + [&](){return state->coordinator.act(disposer);}, + state->out); + if (selectedDisposer.empty()) { + return; + } + state->out.add([=](){ - auto disposer = [=](const rxsc::schedulable&){ - state->source_lifetime.unsubscribe(); - }; - auto selectedDisposer = on_exception( - [&](){return state->coordinator.act(disposer);}, - state->out); - if (selectedDisposer.empty()) { - return; - } + controller.schedule(selectedDisposer.get()); + }); + state->source_lifetime.add([=](){ controller.schedule(selectedDisposer.get()); }); diff --git a/Rx/v2/test/operators/subscribe_on.cpp b/Rx/v2/test/operators/subscribe_on.cpp index 986a989..c8a25f7 100644 --- a/Rx/v2/test/operators/subscribe_on.cpp +++ b/Rx/v2/test/operators/subscribe_on.cpp @@ -5,12 +5,12 @@ namespace rxsc=rx::rxsc; #include "catch.hpp" -static const int static_subscriptions = 100000; +static const int static_subscriptions = 50000; SCENARIO("for loop subscribes to map with subscribe_on and observe_on", "[hide][for][just][subscribe][subscribe_on][observe_on][long][perf]"){ const int& subscriptions = static_subscriptions; GIVEN("a for loop"){ - WHEN("subscribe 100K times"){ + WHEN("subscribe 50K times"){ using namespace std::chrono; typedef steady_clock clock; @@ -21,9 +21,8 @@ SCENARIO("for loop subscribes to map with subscribe_on and observe_on", "[hide][ int c = 0; int n = 1; auto start = clock::now(); - for (int i = 0; i < subscriptions; i++) { - std::atomic_bool done; - rx::observable<>::just(1) + for (int i = 0; i < subscriptions; ++i) { + c += rx::observable<>::just(1) .map([](int i) { std::stringstream serializer; serializer << i; @@ -36,18 +35,55 @@ SCENARIO("for loop subscribes to map with subscribe_on and observe_on", "[hide][ }) .subscribe_on(rx::observe_on_event_loop()) .observe_on(rx::observe_on_event_loop()) - .subscribe([&](int i){ - ++c; - }, - [&](){ - done = true; - }); - while(!done); + .as_blocking() + .count(); } auto finish = clock::now(); auto msElapsed = duration_cast(finish-start); + REQUIRE(subscriptions == c); std::cout << "loop subscribe map subscribe_on observe_on : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; } } } } + +SCENARIO("for loop subscribes to map with subscribe_on", "[hide][subscribe_on_only][for][just][subscribe][subscribe_on][long][perf]"){ + const int& subscriptions = static_subscriptions; + GIVEN("a for loop"){ + WHEN("subscribe 50K times"){ + using namespace std::chrono; + typedef steady_clock clock; + + int runs = 10; + + for (;runs > 0; --runs) { + + int c = 0; + int n = 1; + auto start = clock::now(); + + for (int i = 0; i < subscriptions; ++i) { + c += rx::observable<>:: + just(1). + map([](int i) { + std::stringstream serializer; + serializer << i; + return serializer.str(); + }). + map([](const std::string& s) { + int i; + std::stringstream(s) >> i; + return i; + }). + subscribe_on(rx::observe_on_event_loop()). + as_blocking(). + count(); + } + auto finish = clock::now(); + auto msElapsed = duration_cast(finish-start); + REQUIRE(subscriptions == c); + std::cout << "loop subscribe map subscribe_on : " << n << " subscribed, " << c << " on_next calls, " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + } + } + } +} -- GitLab From 065098dd3175564b9405d7faf55b8e483c0f4ed0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 9 Aug 2014 17:03:59 -0700 Subject: [PATCH 406/782] fix lifetime and workaround bugs in osx condition_variables --- Rx/v2/src/rxcpp/rx-observable.hpp | 67 ++++++++++++++++++++++++++----- 1 file changed, 56 insertions(+), 11 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index b8c6a1a..b64c9fe 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -183,22 +183,61 @@ class blocking_observable -> composite_subscription { std::mutex lock; std::condition_variable wake; - std::atomic_bool disposed; + composite_subscription cs; + struct tracking + { + ~tracking(){ + if (!disposed || !wakened) abort(); + } + tracking() : + disposed(false), + wakened(false), + false_wakes(0), + true_wakes(0) + { + } + std::atomic_bool disposed; + std::atomic_bool wakened; + std::atomic_int false_wakes; + std::atomic_int true_wakes; + }; + auto track = std::make_shared(); + auto scbr = make_subscriber(std::forward(an)...); - auto cs = scbr.get_subscription(); - cs.add([&](){ - disposed = true; - wake.notify_one(); - }); + cs = scbr.get_subscription(); + cs.add( + [&, track](){ + // OSX geting invalid x86 op if notify_one is after the disposed = true + // presumably because the condition_variable may already have been awakened + // and is now sitting in a while loop on disposed + wake.notify_one(); + track->disposed = true; + }); std::unique_lock guard(lock); - source.subscribe(scbr); - wake.wait(guard, [&](){return !!disposed;}); - return cs; + source.subscribe(std::move(scbr)); + wake.wait(guard, + [&, track](){ + // this is really not good. + // false wakeups were never followed by true wakeups on OSX so.. + + // anyways this gets triggered before disposed is set now so wait. + while (!track->disposed) { + ++track->false_wakes; + } + ++track->true_wakes; + return true; + }); + track->wakened = true; + if (!track->disposed || !track->wakened) abort(); + return composite_subscription::empty(); } public: typedef typename std::decay::type observable_type; observable_type source; + ~blocking_observable() + { + } blocking_observable(observable_type s) : source(std::move(s)) {} /// @@ -221,12 +260,14 @@ public: rxu::maybe result; composite_subscription cs; subscribe(cs, [&](T v){result.reset(v); cs.unsubscribe();}); + if (result.empty()) abort(); return result.get(); } T last() const { rxu::maybe result; subscribe([&](T v){result.reset(v);}); + if (result.empty()) abort(); return result.get(); } @@ -316,6 +357,10 @@ public: static_assert(rxo::is_operator::value || rxs::is_source::value, "observable must wrap an operator or source"); + ~observable() + { + } + observable() { } @@ -423,7 +468,7 @@ public: /// for each item from this observable use Selector to produce an item to emit from the new observable that is returned. /// template - auto map(Selector&& s) const + auto map(Selector s) const -> decltype(EXPLICIT_THIS lift::value_type>(rxo::detail::map(std::move(s)))) { return lift::value_type>(rxo::detail::map(std::move(s))); } @@ -796,7 +841,7 @@ public: auto subscribe_on(Coordination cn) const -> observable::value_type, rxo::detail::subscribe_on> { return observable::value_type, rxo::detail::subscribe_on>( - rxo::detail::subscribe_on(*this, std::forward(cn))); + rxo::detail::subscribe_on(*this, std::move(cn))); } /// observe_on -> -- GitLab From c655280fa2ca28e59137730ee203eae04bf71741 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 9 Aug 2014 17:04:20 -0700 Subject: [PATCH 407/782] add group_by test (pi series) --- Rx/v2/src/rxcpp/rx-grouped_observable.hpp | 12 +++ Rx/v2/test/operators/group_by.cpp | 125 ++++++++++++++++++++++ 2 files changed, 137 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp index a56878c..3b248af 100644 --- a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp @@ -46,6 +46,9 @@ private: }; std::shared_ptr state; + template + friend bool operator==(const dynamic_grouped_observable&, const dynamic_grouped_observable&); + template void construct(const dynamic_grouped_observable& o, const tag_dynamic_grouped_observable&) { state = o.state; @@ -120,6 +123,15 @@ public: } }; +template +inline bool operator==(const dynamic_grouped_observable& lhs, const dynamic_grouped_observable& rhs) { + return lhs.state == rhs.state; +} +template +inline bool operator!=(const dynamic_grouped_observable& lhs, const dynamic_grouped_observable& rhs) { + return !(lhs == rhs); +} + template grouped_observable make_dynamic_grouped_observable(Source&& s) { return grouped_observable(dynamic_grouped_observable(std::forward(s))); diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index ac1b8cc..d3e1913 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -8,6 +8,131 @@ namespace rxsc=rxcpp::schedulers; #include +SCENARIO("range partitioned by group_by across hardware threads to derive pi", "[hide][pi][group_by][observe_on][long][perf]"){ + GIVEN("a for loop"){ + WHEN("partitioning pi series across all hardware threads"){ + + std::atomic_int c(0); + auto pi = [&](int k) { + ++c; + return ( k % 2 == 0 ? -4.0L : 4.0L ) / ( ( 2.0L * k ) - 1.0L ); + }; + + using namespace std::chrono; + auto start = steady_clock::now(); + + // share an output thread across all the producer threads + auto outputthread = rxcpp::observe_on_one_worker(rxcpp::observe_on_new_thread().create_coordinator().get_scheduler()); + + // use all available hardware threads + auto total = rxcpp::observable<>::range(0, 19). + group_by( + [](int i) -> int {return i % std::thread::hardware_concurrency();}, + [](int i){return i;}). + map( + [=, &c](rxcpp::grouped_observable onproc) { + auto key = onproc.get_key(); + // share a producer thread across all the ranges in this group + auto producerthread = rxcpp::observe_on_one_worker(rxcpp::observe_on_new_thread().create_coordinator().get_scheduler()); + return onproc. + map( + [=, &c](int index){ + static const int chunk = 1000000; + auto first = (chunk * index) + 1; + auto last = chunk * (index + 1); + std::cout << std::setw(3) << index << ": range - " << first << "-" << last << std::endl; + + return rxcpp::observable<>::range(first, last, producerthread). + map(pi). + sum(). // each thread maps and reduces its contribution to the answer + map( + [=](long double v){ + std::stringstream message; + message << key << " on " << std::this_thread::get_id() << " - value: " << std::setprecision(16) << v; + return std::make_tuple(message.str(), v); + }). + as_dynamic(); + }). + concat(). // only subscribe to one range at a time in this group. + observe_on(outputthread). + map(rxcpp::util::apply_to( + [](std::string message, long double v){ + std::cout << message << std::endl; + return v; + })). + as_dynamic(); + }). + merge(). + sum(). // reduces the contributions from all the threads to the answer + as_blocking(). + last(); + + std::cout << std::setprecision(16) << "Pi: " << total << std::endl; + auto finish = steady_clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "pi using group_by and concat to partition the work : " << c << " calls to pi(), " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + + } + } +} + +SCENARIO("range partitioned by dividing work across hardware threads to derive pi", "[hide][pi][observe_on][long][perf]"){ + GIVEN("a for loop"){ + WHEN("partitioning pi series across all hardware threads"){ + + std::atomic_int c(0); + auto pi = [&](int k) { + ++c; + return ( k % 2 == 0 ? -4.0L : 4.0L ) / ( ( 2.0L * k ) - 1.0L ); + }; + + using namespace std::chrono; + auto start = steady_clock::now(); + + // share an output thread across all the producer threads + auto outputthread = rxcpp::observe_on_one_worker(rxcpp::observe_on_new_thread().create_coordinator().get_scheduler()); + + // use all available hardware threads + auto total = rxcpp::observable<>::range(0, std::thread::hardware_concurrency() - 1). + map( + [=, &c](int index){ + // partition equally across threads + static const int chunk = 20000000 / std::thread::hardware_concurrency(); + auto first = (chunk * index) + 1; + auto last = chunk * (index + 1); + std::cout << std::setw(3) << index << ": range - " << first << "-" << last << std::endl; + + return rxcpp::observable<>::range(first, last, rxcpp::observe_on_new_thread()). + map(pi). + sum(). // each thread maps and reduces its contribution to the answer + map( + [=](long double v){ + std::stringstream message; + message << std::this_thread::get_id() << " - value: " << std::setprecision(16) << v; + return std::make_tuple(message.str(), v); + }). + as_dynamic(); + }). + observe_on(outputthread). + merge(). + map(rxcpp::util::apply_to( + [](std::string message, long double v){ + std::cout << message << std::endl; + return v; + })). + sum(). // reduces the contributions from all the threads to the answer + as_blocking(). + last(); + + std::cout << std::setprecision(16) << "Pi: " << total << std::endl; + auto finish = steady_clock::now(); + auto msElapsed = duration_cast(finish-start); + std::cout << "pi using division of the whole range to partition the work : " << c << " calls to pi(), " << msElapsed.count() << "ms elapsed, " << c / (msElapsed.count() / 1000.0) << " ops/sec" << std::endl; + + } + } +} + char whitespace(char c) { return std::isspace(c, std::locale::classic()); } -- GitLab From 7307e7e71c042cead948e330a2ab2485921318d4 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 9 Aug 2014 18:16:49 -0700 Subject: [PATCH 408/782] windows workarounds --- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 29 -------------------- Rx/v2/src/rxcpp/rx-observable.hpp | 35 ++++++++++++++++--------- Rx/v2/test/operators/group_by.cpp | 6 +++-- projects/CMake/CMakeLists.txt | 9 ++++--- 4 files changed, 31 insertions(+), 48 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index e53f2c5..1c721e4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -186,35 +186,6 @@ struct initialize_seeder { } }; -template -struct last { - typedef rxu::maybe::type> seed_type; - seed_type seed() { - return seed_type{}; - } - seed_type operator()(const seed_type& a, T v) { - return seed_type(v); - } - typename std::decay::type operator()(seed_type a) { - // should abort if a is empty - return a.get(); - } -}; - -template -struct count { - typedef int seed_type; - seed_type seed() { - return seed_type{}; - } - seed_type operator()(seed_type a, T v) { - return ++a; - } - seed_type operator()(seed_type a) { - return a; - } -}; - template struct average { struct seed_type diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index b64c9fe..bbb9599 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -186,15 +186,16 @@ class blocking_observable composite_subscription cs; struct tracking { - ~tracking(){ + ~tracking() + { if (!disposed || !wakened) abort(); } - tracking() : - disposed(false), - wakened(false), - false_wakes(0), - true_wakes(0) + tracking() { + disposed = false; + wakened = false; + false_wakes = 0; + true_wakes = 0; } std::atomic_bool disposed; std::atomic_bool wakened; @@ -218,7 +219,7 @@ class blocking_observable wake.wait(guard, [&, track](){ // this is really not good. - // false wakeups were never followed by true wakeups on OSX so.. + // false wakeups were never followed by true wakeups so.. // anyways this gets triggered before disposed is set now so wait. while (!track->disposed) { @@ -883,17 +884,13 @@ public: /// for each item from this observable reduce it by sending only the last item. /// auto last() const - -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { - return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, rxo::detail::last(), rxo::detail::last(), rxo::detail::last().seed()); - } + -> observable; /// count -> /// for each item from this observable reduce it by incrementing a count. /// auto count() const - -> typename defer_reduce, rxu::defer_type, rxu::defer_type>::observable_type { - return defer_reduce, rxu::defer_type, rxu::defer_type>::make(source_operator, rxo::detail::count(), rxo::detail::count(), rxo::detail::count().seed()); - } + -> observable; /// sum -> /// for each item from this observable reduce it by adding to the previous items. @@ -1053,12 +1050,24 @@ public: }; +template +auto observable::last() const + -> observable { + rxu::util::maybe seed; + return this->reduce(seed, [](rxu::util::maybe, T t){return rxu::util::maybe(std::move(t));}, [](rxu::util::maybe result){return result.get();}); +} + template auto observable::first() const -> observable { return this->take(1).last(); } +template +auto observable::count() const + -> observable { + return this->reduce(0, [](int current, const T&){return ++current;}, [](int result){return result;}); +} template inline bool operator==(const observable& lhs, const observable& rhs) { diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index d3e1913..1d85193 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -12,7 +12,8 @@ SCENARIO("range partitioned by group_by across hardware threads to derive pi", " GIVEN("a for loop"){ WHEN("partitioning pi series across all hardware threads"){ - std::atomic_int c(0); + std::atomic_int c; + c = 0; auto pi = [&](int k) { ++c; return ( k % 2 == 0 ? -4.0L : 4.0L ) / ( ( 2.0L * k ) - 1.0L ); @@ -80,7 +81,8 @@ SCENARIO("range partitioned by dividing work across hardware threads to derive p GIVEN("a for loop"){ WHEN("partitioning pi series across all hardware threads"){ - std::atomic_int c(0); + std::atomic_int c; + c = 0; auto pi = [&](int k) { ++c; return ( k % 2 == 0 ? -4.0L : 4.0L ) / ( ( 2.0L * k ) - 1.0L ); diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 99c20f2..b71b95e 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -64,12 +64,13 @@ set(TEST_SOURCES add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) -set(OP_SOURCES +# define the sources of the self test +set(ONE_SOURCES ${TEST_DIR}/test.cpp - ${TEST_DIR}/operators/group_by.cpp + ${TEST_DIR}/operators/subscribe_on.cpp ) -#add_executable(op_test ${OP_SOURCES}) -#TARGET_LINK_LIBRARIES(op_test ${CMAKE_THREAD_LIBS_INIT}) +add_executable(one_test ${ONE_SOURCES}) +TARGET_LINK_LIBRARIES(one_test ${CMAKE_THREAD_LIBS_INIT}) set(EXAMPLES_DIR ${RXCPP_DIR}/Rx/v2/examples) -- GitLab From 80f3ca2178549b3c37bd566f6cce9ea8340c6db2 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 9 Aug 2014 18:26:53 -0700 Subject: [PATCH 409/782] remove redundant namspace --- Rx/v2/src/rxcpp/rx-observable.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index bbb9599..a12d88b 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -1053,8 +1053,8 @@ public: template auto observable::last() const -> observable { - rxu::util::maybe seed; - return this->reduce(seed, [](rxu::util::maybe, T t){return rxu::util::maybe(std::move(t));}, [](rxu::util::maybe result){return result.get();}); + rxu::maybe seed; + return this->reduce(seed, [](rxu::maybe, T t){return rxu::maybe(std::move(t));}, [](rxu::maybe result){return result.get();}); } template -- GitLab From 1e80c4b244fb764d6d4a1da5a6d40bc1e27645ca Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 9 Aug 2014 20:32:39 -0700 Subject: [PATCH 410/782] linux fixes --- projects/CMake/CMakeLists.txt | 2 +- projects/scripts/travis-install.sh | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b71b95e..d5e260f 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -7,7 +7,7 @@ MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) FIND_PACKAGE(Threads) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") + list( APPEND CMAKE_CXX_FLAGS " -std=c++11 -ftemplate-depth=1024 ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 8f9f5fe..466c1fa 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -15,6 +15,8 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then if [ "$CC" = clang ]; then sudo apt-get install -q --fix-missing clang-3.6 + sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.6 20 + sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.6 20 fi if [ "$CC" = gcc ]; then -- GitLab From c9774c09c7f3a880dff80cb46a0408bcde77274e Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 7 Aug 2014 19:08:59 +0400 Subject: [PATCH 411/782] Add scope operator --- Rx/v2/src/rxcpp/rx-observable.hpp | 5 ++ Rx/v2/src/rxcpp/rx-sources.hpp | 1 + Rx/v2/src/rxcpp/rx-subscription.hpp | 52 ++++++++++++ Rx/v2/src/rxcpp/sources/rx-scope.hpp | 122 +++++++++++++++++++++++++++ 4 files changed, 180 insertions(+) create mode 100644 Rx/v2/src/rxcpp/sources/rx-scope.hpp diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a12d88b..3e083ed 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -1206,6 +1206,11 @@ public: -> decltype(rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o)) { return rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o); } + template + static auto scope(ResourceFactory rf, ObservableFactory of) + -> decltype(rxs::scope(std::move(rf), std::move(of))) { + return rxs::scope(std::move(rf), std::move(of)); + } }; diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index c9fb73f..25d40ec 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -42,5 +42,6 @@ namespace rxs=sources; #include "sources/rx-defer.hpp" #include "sources/rx-never.hpp" #include "sources/rx-error.hpp" +#include "sources/rx-scope.hpp" #endif diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 3ee8441..5875ac5 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -441,6 +441,58 @@ inline bool operator!=(const composite_subscription& lhs, const composite_subscr //static RXCPP_SELECT_ANY composite_subscription composite_subscription::shared_empty = composite_subscription(detail::tag_composite_subscription_empty()); + +template +class resource : public subscription_base +{ +public: + typedef typename composite_subscription::weak_subscription weak_subscription; + + resource(T t, composite_subscription cs = composite_subscription()) + : lifetime(std::move(cs)) + , value(new std::shared_ptr(new T(std::move(t)))) + { + auto localValue = value; + lifetime.add( + [localValue](){ + localValue->reset(); + } + ); + } + + T& get() const { + return *value.get()->get(); + } + composite_subscription& get_subscription() const { + return lifetime; + } + + bool is_subscribed() const { + return lifetime.is_subscribed(); + } + weak_subscription add(subscription s) const { + return lifetime.add(std::move(s)); + } + template + auto add(F f) const + -> typename std::enable_if::value, weak_subscription>::type { + return lifetime.add(make_subscription(std::move(f))); + } + void remove(weak_subscription w) const { + return lifetime.remove(std::move(w)); + } + void clear() const { + return lifetime.clear(); + } + void unsubscribe() const { + return lifetime.unsubscribe(); + } + +protected: + composite_subscription lifetime; + std::shared_ptr> value; +}; + } #endif diff --git a/Rx/v2/src/rxcpp/sources/rx-scope.hpp b/Rx/v2/src/rxcpp/sources/rx-scope.hpp new file mode 100644 index 0000000..43b0194 --- /dev/null +++ b/Rx/v2/src/rxcpp/sources/rx-scope.hpp @@ -0,0 +1,122 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_SOURCES_RX_SCOPE_HPP) +#define RXCPP_SOURCES_RX_SCOPE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace sources { + +namespace detail { + +template +struct scope_traits +{ + typedef typename std::decay::type resource_factory_type; + typedef typename std::decay::type observable_factory_type; + typedef decltype((*(resource_factory_type*)nullptr)()) resource_type; + typedef decltype((*(observable_factory_type*)nullptr)(resource_type())) collection_type; + typedef typename collection_type::value_type value_type; + + static_assert(is_subscription::value, "ResourceFactory must return a subscription"); +}; + +template +struct scope : public source_base::value_type> +{ + typedef scope_traits traits; + typedef typename traits::resource_factory_type resource_factory_type; + typedef typename traits::observable_factory_type observable_factory_type; + typedef typename traits::resource_type resource_type; + typedef typename traits::value_type value_type; + + struct values + { + values(resource_factory_type rf, observable_factory_type of) + : resource_factory(std::move(rf)) + , observable_factory(std::move(of)) + { + } + resource_factory_type resource_factory; + observable_factory_type observable_factory; + }; + values initial; + + + scope(resource_factory_type rf, observable_factory_type of) + : initial(std::move(rf), std::move(of)) + { + } + + template + void on_subscribe(Subscriber o) const { + + struct state_type + : public std::enable_shared_from_this + , public values + { + state_type(values i, Subscriber o) + : values(i) + , out(std::move(o)) + { + out.add(lifetime); + } + Subscriber out; + rxu::detail::maybe resource; + composite_subscription lifetime; + }; + + auto state = std::shared_ptr(new state_type(initial, std::move(o))); + + state->resource = on_exception( + [&](){return state->resource_factory(); }, + state->out); + if (state->resource.empty()) { + return; + } + + auto selectedCollection = on_exception( + [state](){return state->observable_factory(state->resource.get()); }, + state->out); + if (selectedCollection.empty()) { + return; + } + + selectedCollection->subscribe(make_subscriber( + state->lifetime, + // on_next + [state](value_type st) { + state->out.on_next(st); + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + state->resource->unsubscribe(); + }, + // on_completed + [state]() { + state->out.on_completed(); + state->resource->unsubscribe(); + } + )); + } +}; + +} + +template +auto scope(ResourceFactory rf, ObservableFactory of) + -> observable::value_type, detail::scope> { + return observable::value_type, detail::scope>( + detail::scope(std::move(rf), std::move(of))); +} + +} + +} + +#endif -- GitLab From 609ec19178ac2c383f52571cf0d9ee7c2d1df527 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 7 Aug 2014 19:13:39 +0400 Subject: [PATCH 412/782] Add tests for scope operator --- Rx/v2/test/sources/scope.cpp | 427 ++++++++++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 1 + 2 files changed, 428 insertions(+) create mode 100644 Rx/v2/test/sources/scope.cpp diff --git a/Rx/v2/test/sources/scope.cpp b/Rx/v2/test/sources/scope.cpp new file mode 100644 index 0000000..4201b50 --- /dev/null +++ b/Rx/v2/test/sources/scope.cpp @@ -0,0 +1,427 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("scope, cold observable", "[scope][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + rxu::detail::maybe> xs; + + typedef rx::resource> resource; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + return resource(rxu::to_vector({1, 2, 3, 4, 5})); + }, + [&](resource& r){ + auto msg = std::vector::recorded_type>(); + int time = 10; + auto values = r.get(); + std::for_each(values.begin(), values.end(), [&](int &v){ + msg.push_back(on.on_next(time, v)); + time += 10; + }); + msg.push_back(on.on_completed(time)); + xs.reset(sc.make_cold_observable(msg)); + return xs.get(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_next(210, 1), + on.on_next(220, 2), + on.on_next(230, 3), + on.on_next(240, 4), + on.on_next(250, 5), + on.on_completed(260) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 260) + }); + auto actual = xs.get().subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scope, hot observable", "[scope][sources]"){ + GIVEN("a test hot observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + rxu::detail::maybe> xs; + + typedef rx::resource> resource; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + return resource(rxu::to_vector({1, 2, 3, 4, 5})); + }, + [&](resource& r){ + auto msg = std::vector::recorded_type>(); + int time = 210; + auto values = r.get(); + std::for_each(values.begin(), values.end(), [&](int &v){ + msg.push_back(on.on_next(time, v)); + time += 10; + }); + msg.push_back(on.on_completed(time)); + xs.reset(sc.make_hot_observable(msg)); + return xs.get(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_next(210, 1), + on.on_next(220, 2), + on.on_next(230, 3), + on.on_next(240, 4), + on.on_next(250, 5), + on.on_completed(260) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 260) + }); + auto actual = xs.get().subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scope, complete", "[scope][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int resource_factory_invoked = 0; + int observable_factory_invoked = 0; + + rxu::detail::maybe> xs; + + typedef rx::resource resource; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + ++resource_factory_invoked; + return resource(sc.clock()); + }, + [&](resource& r){ + ++observable_factory_invoked; + xs.reset(sc.make_cold_observable(rxu::to_vector({ + on.on_next(100, r.get()), + on.on_completed(200) + }))); + return xs.get(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("Resource factory is used once"){ + REQUIRE(1 == resource_factory_invoked); + } + + THEN("Observable factory is used once"){ + REQUIRE(1 == observable_factory_invoked); + } + + THEN("the output stops on completion"){ + auto required = rxu::to_vector({ + on.on_next(300, 200), + on.on_completed(400) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); + auto actual = xs.get().subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scope, error", "[scope][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("scope on_error from source"); + + int resource_factory_invoked = 0; + int observable_factory_invoked = 0; + + rxu::detail::maybe> xs; + + typedef rx::resource resource; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + ++resource_factory_invoked; + return resource(sc.clock()); + }, + [&](resource& r){ + ++observable_factory_invoked; + xs.reset(sc.make_cold_observable(rxu::to_vector({ + on.on_next(100, r.get()), + on.on_error(200, ex) + }))); + return xs.get(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("Resource factory is used once"){ + REQUIRE(1 == resource_factory_invoked); + } + + THEN("Observable factory is used once"){ + REQUIRE(1 == observable_factory_invoked); + } + + THEN("the output stops on error"){ + auto required = rxu::to_vector({ + on.on_next(300, 200), + on.on_error(400, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 400) + }); + auto actual = xs.get().subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scope, dispose", "[scope][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + int resource_factory_invoked = 0; + int observable_factory_invoked = 0; + + rxu::detail::maybe> xs; + + typedef rx::resource resource; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + ++resource_factory_invoked; + return resource(sc.clock()); + }, + [&](resource& r){ + ++observable_factory_invoked; + xs.reset(sc.make_cold_observable(rxu::to_vector({ + on.on_next(100, r.get()), + on.on_next(1000, r.get() + 1) + }))); + return xs.get(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("Resource factory is used once"){ + REQUIRE(1 == resource_factory_invoked); + } + + THEN("Observable factory is used once"){ + REQUIRE(1 == observable_factory_invoked); + } + + THEN("the output contains resulting ints"){ + auto required = rxu::to_vector({ + on.on_next(300, 200) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = xs.get().subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scope, throw resource selector", "[scope][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("scope on_error from source"); + + int resource_factory_invoked = 0; + int observable_factory_invoked = 0; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + ++resource_factory_invoked; + throw ex; + return rx::make_subscription(); + }, + [&](rx::subscription& s){ + ++observable_factory_invoked; + return rx::observable<>::never(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("Resource factory is used once"){ + REQUIRE(1 == resource_factory_invoked); + } + + THEN("Observable factory is not used"){ + REQUIRE(0 == observable_factory_invoked); + } + + THEN("the output stops on error"){ + auto required = rxu::to_vector({ + on.on_error(200, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("scope, throw resource usage", "[scope][sources]"){ + GIVEN("a test cold observable of ints"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("scope on_error from source"); + + int resource_factory_invoked = 0; + int observable_factory_invoked = 0; + + WHEN("created by scope"){ + + auto res = w.start( + [&]() { + return rx::observable<>:: + scope( + [&](){ + ++resource_factory_invoked; + return rx::make_subscription(); + }, + [&](rx::subscription& s){ + ++observable_factory_invoked; + throw ex; + return rx::observable<>::never(); + } + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("Resource factory is used once"){ + REQUIRE(1 == resource_factory_invoked); + } + + THEN("Observable factory is used once"){ + REQUIRE(1 == observable_factory_invoked); + } + + THEN("the output stops on error"){ + auto required = rxu::to_vector({ + on.on_error(200, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index d5e260f..5ed89a9 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -36,6 +36,7 @@ set(TEST_SOURCES ${TEST_DIR}/sources/create.cpp ${TEST_DIR}/sources/defer.cpp ${TEST_DIR}/sources/interval.cpp + ${TEST_DIR}/sources/scope.cpp ${TEST_DIR}/operators/buffer.cpp ${TEST_DIR}/operators/combine_latest.1.cpp ${TEST_DIR}/operators/combine_latest.2.cpp -- GitLab From 8e617019b3a111624de99309c2febbf5d27a41ab Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Fri, 8 Aug 2014 14:00:20 +0400 Subject: [PATCH 413/782] Small changes on scope operator --- Rx/v2/src/rxcpp/rx-subscription.hpp | 8 ++++---- Rx/v2/src/rxcpp/sources/rx-scope.hpp | 23 +++-------------------- Rx/v2/test/sources/scope.cpp | 22 +++++++++++++--------- 3 files changed, 20 insertions(+), 33 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 5875ac5..2f61652 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -450,7 +450,7 @@ public: resource(T t, composite_subscription cs = composite_subscription()) : lifetime(std::move(cs)) - , value(new std::shared_ptr(new T(std::move(t)))) + , value(std::make_shared>(std::make_unique(std::move(t)))) { auto localValue = value; lifetime.add( @@ -460,10 +460,10 @@ public: ); } - T& get() const { + T& get() { return *value.get()->get(); } - composite_subscription& get_subscription() const { + composite_subscription& get_subscription() { return lifetime; } @@ -490,7 +490,7 @@ public: protected: composite_subscription lifetime; - std::shared_ptr> value; + std::shared_ptr> value; }; } diff --git a/Rx/v2/src/rxcpp/sources/rx-scope.hpp b/Rx/v2/src/rxcpp/sources/rx-scope.hpp index 43b0194..589493e 100644 --- a/Rx/v2/src/rxcpp/sources/rx-scope.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-scope.hpp @@ -63,11 +63,9 @@ struct scope : public source_base resource; - composite_subscription lifetime; }; auto state = std::shared_ptr(new state_type(initial, std::move(o))); @@ -78,7 +76,8 @@ struct scope : public source_baseresource.empty()) { return; } - + state->out.add(state->resource->get_subscription()); + auto selectedCollection = on_exception( [state](){return state->observable_factory(state->resource.get()); }, state->out); @@ -86,23 +85,7 @@ struct scope : public source_basesubscribe(make_subscriber( - state->lifetime, - // on_next - [state](value_type st) { - state->out.on_next(st); - }, - // on_error - [state](std::exception_ptr e) { - state->out.on_error(e); - state->resource->unsubscribe(); - }, - // on_completed - [state]() { - state->out.on_completed(); - state->resource->unsubscribe(); - } - )); + selectedCollection->subscribe(state->out); } }; diff --git a/Rx/v2/test/sources/scope.cpp b/Rx/v2/test/sources/scope.cpp index 4201b50..b8d36cb 100644 --- a/Rx/v2/test/sources/scope.cpp +++ b/Rx/v2/test/sources/scope.cpp @@ -25,7 +25,7 @@ SCENARIO("scope, cold observable", "[scope][sources]"){ [&](){ return resource(rxu::to_vector({1, 2, 3, 4, 5})); }, - [&](resource& r){ + [&](resource r){ auto msg = std::vector::recorded_type>(); int time = 10; auto values = r.get(); @@ -86,7 +86,7 @@ SCENARIO("scope, hot observable", "[scope][sources]"){ [&](){ return resource(rxu::to_vector({1, 2, 3, 4, 5})); }, - [&](resource& r){ + [&](resource r){ auto msg = std::vector::recorded_type>(); int time = 210; auto values = r.get(); @@ -151,7 +151,7 @@ SCENARIO("scope, complete", "[scope][sources]"){ ++resource_factory_invoked; return resource(sc.clock()); }, - [&](resource& r){ + [&](resource r){ ++observable_factory_invoked; xs.reset(sc.make_cold_observable(rxu::to_vector({ on.on_next(100, r.get()), @@ -218,7 +218,7 @@ SCENARIO("scope, error", "[scope][sources]"){ ++resource_factory_invoked; return resource(sc.clock()); }, - [&](resource& r){ + [&](resource r){ ++observable_factory_invoked; xs.reset(sc.make_cold_observable(rxu::to_vector({ on.on_next(100, r.get()), @@ -283,7 +283,7 @@ SCENARIO("scope, dispose", "[scope][sources]"){ ++resource_factory_invoked; return resource(sc.clock()); }, - [&](resource& r){ + [&](resource r){ ++observable_factory_invoked; xs.reset(sc.make_cold_observable(rxu::to_vector({ on.on_next(100, r.get()), @@ -335,6 +335,8 @@ SCENARIO("scope, throw resource selector", "[scope][sources]"){ int resource_factory_invoked = 0; int observable_factory_invoked = 0; + typedef rx::resource resource; + WHEN("created by scope"){ auto res = w.start( @@ -344,9 +346,9 @@ SCENARIO("scope, throw resource selector", "[scope][sources]"){ [&](){ ++resource_factory_invoked; throw ex; - return rx::make_subscription(); + return resource(sc.clock()); }, - [&](rx::subscription& s){ + [&](resource r){ ++observable_factory_invoked; return rx::observable<>::never(); } @@ -386,6 +388,8 @@ SCENARIO("scope, throw resource usage", "[scope][sources]"){ int resource_factory_invoked = 0; int observable_factory_invoked = 0; + typedef rx::resource resource; + WHEN("created by scope"){ auto res = w.start( @@ -394,9 +398,9 @@ SCENARIO("scope, throw resource usage", "[scope][sources]"){ scope( [&](){ ++resource_factory_invoked; - return rx::make_subscription(); + return resource(sc.clock()); }, - [&](rx::subscription& s){ + [&](resource r){ ++observable_factory_invoked; throw ex; return rx::observable<>::never(); -- GitLab From 181102a831780ab5cffba20051cfe24ea3bc9335 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Fri, 8 Aug 2014 15:27:10 +0400 Subject: [PATCH 414/782] Fixes for GCC --- Rx/v2/src/rxcpp/rx-subscription.hpp | 4 ++-- Rx/v2/src/rxcpp/sources/rx-scope.hpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 2f61652..3e70c87 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -448,9 +448,9 @@ class resource : public subscription_base public: typedef typename composite_subscription::weak_subscription weak_subscription; - resource(T t, composite_subscription cs = composite_subscription()) + resource(T t = T(), composite_subscription cs = composite_subscription()) : lifetime(std::move(cs)) - , value(std::make_shared>(std::make_unique(std::move(t)))) + , value(std::make_shared>(std::unique_ptr(new T(std::move(t))))) { auto localValue = value; lifetime.add( diff --git a/Rx/v2/src/rxcpp/sources/rx-scope.hpp b/Rx/v2/src/rxcpp/sources/rx-scope.hpp index 589493e..1b7a26d 100644 --- a/Rx/v2/src/rxcpp/sources/rx-scope.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-scope.hpp @@ -68,7 +68,7 @@ struct scope : public source_base resource; }; - auto state = std::shared_ptr(new state_type(initial, std::move(o))); + auto state = std::make_shared(state_type(initial, std::move(o))); state->resource = on_exception( [&](){return state->resource_factory(); }, -- GitLab From 4fe1497dd8e2052f157113118d85a5ec5f6a3f4c Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 11 Aug 2014 13:01:14 +0400 Subject: [PATCH 415/782] Small changes on resource class --- Rx/v2/src/rxcpp/rx-subscription.hpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 3e70c87..6263a1f 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -448,9 +448,15 @@ class resource : public subscription_base public: typedef typename composite_subscription::weak_subscription weak_subscription; - resource(T t = T(), composite_subscription cs = composite_subscription()) + resource() + : lifetime(composite_subscription()) + , value(std::make_shared>()) + { + } + + explicit resource(T t, composite_subscription cs = composite_subscription()) : lifetime(std::move(cs)) - , value(std::make_shared>(std::unique_ptr(new T(std::move(t))))) + , value(std::make_shared>(rxu::detail::maybe(std::move(t)))) { auto localValue = value; lifetime.add( @@ -461,7 +467,7 @@ public: } T& get() { - return *value.get()->get(); + return value.get()->get(); } composite_subscription& get_subscription() { return lifetime; @@ -490,7 +496,7 @@ public: protected: composite_subscription lifetime; - std::shared_ptr> value; + std::shared_ptr> value; }; } -- GitLab From ae454dd8ec80df01781b4421e75daeabd60d26b0 Mon Sep 17 00:00:00 2001 From: jonathan pickett Date: Thu, 21 Aug 2014 18:32:52 -0700 Subject: [PATCH 416/782] added retry operator --- Rx/v2/src/rxcpp/operators/rx-retry.hpp | 118 ++++++++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 21 ++++ Rx/v2/src/rxcpp/rx-operators.hpp | 2 +- Rx/v2/test/operators/retry.cpp | 146 +++++++++++++++++++++++++ 4 files changed, 286 insertions(+), 1 deletion(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-retry.hpp create mode 100644 Rx/v2/test/operators/retry.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-retry.hpp b/Rx/v2/src/rxcpp/operators/rx-retry.hpp new file mode 100644 index 0000000..112edef --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-retry.hpp @@ -0,0 +1,118 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_RETRY_HPP) +#define RXCPP_OPERATORS_RX_RETRY_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + + namespace operators { + + namespace detail { + + template + struct retry : public operator_base { + typedef typename std::decay::type source_type; + typedef typename std::decay::type count_type; + struct values { + values(source_type s, count_type t) + : source(std::move(s)) + , remaining(std::move(t)) + , retry_infinitely(t == 0) { + } + source_type source; + count_type remaining; + bool retry_infinitely; + }; + values initial; + + retry(source_type s, count_type t) + : initial(std::move(s), std::move(t)) { + } + + template + void on_subscribe(const Subscriber& s) const { + + typedef Subscriber output_type; + struct state_type + : public std::enable_shared_from_this + , public values { + state_type(const values& i, const output_type& oarg) + : values(i) + , source_lifetime(composite_subscription::empty()) + , out(oarg) { + } + composite_subscription source_lifetime; + output_type out; + + void do_subscribe() { + auto state = this->shared_from_this(); + + state->source_lifetime = composite_subscription(); + state->out.add(state->source_lifetime); + + state->source.subscribe( + state->out, + state->source_lifetime, + // on_next + [state](T t) { + state->out.on_next(t); + }, + // on_error + [state](std::exception_ptr e) { + if (state->retry_infinitely || (--state->remaining >= 0)) { + state->do_subscribe(); + } else { + state->out.on_error(e); + } + }, + // on_completed + [state]() { + + // JEP: never appeears to be called? + + state->out.on_completed(); + } + ); + } + }; + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new state_type(initial, s)); + + // start the first iteration + state->do_subscribe(); + } + }; + + template + class retry_factory { + typedef typename std::decay::type count_type; + count_type count; + public: + retry_factory(count_type t) : count(std::move(t)) {} + + template + auto operator()(Observable&& source) + -> observable::type::value_type, retry::type::value_type, Observable, count_type>> { + return observable::type::value_type, retry::type::value_type, Observable, count_type>>( + retry::type::value_type, Observable, count_type>(std::forward(source), count)); + } + }; + + } + + template + auto retry(T&& t) + -> detail::retry_factory { + return detail::retry_factory(std::forward(t)); + } + + } + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a12d88b..a6592b7 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -1038,6 +1038,27 @@ public: rxo::detail::repeat(*this, t)); } + /// retry -> + /// infinitely retrys this observable + /// + /// + auto retry() const + -> observable> { + return observable>( + rxo::detail::retry(*this, 0)); + } + + /// retry -> + /// retrys this observable for given number of times + /// + /// + template + auto retry(Count t) const + -> observable> { + return observable>( + rxo::detail::retry(*this, t)); + } + /// start_with -> /// start with the supplied values, then concatenate this observable /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index b62ddd6..3b8d21a 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -63,5 +63,5 @@ namespace rxo=operators; #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" #include "operators/rx-window.hpp" - +#include "operators/rx-retry.hpp" #endif diff --git a/Rx/v2/test/operators/retry.cpp b/Rx/v2/test/operators/retry.cpp new file mode 100644 index 0000000..9bec879 --- /dev/null +++ b/Rx/v2/test/operators/retry.cpp @@ -0,0 +1,146 @@ +#include "rxcpp/rx.hpp" +namespace rxu = rxcpp::util; +namespace rxsc = rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("retry, basic test", "[retry][operators]") { + GIVEN("hot observable of 3x4x7 ints with errors inbetween the groups. Infinite retry.") { + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + std::runtime_error ex("retry on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(300, 1), + on.on_next(325, 2), + on.on_next(350, 3), + on.on_error(400, ex), + on.on_next(425, 1), + on.on_next(450, 2), + on.on_next(475, 3), + on.on_next(500, 4), + on.on_error(525, ex), + on.on_next(550, 1), + on.on_next(575, 2), + on.on_next(600, 3), + on.on_next(625, 4), + on.on_next(650, 5), + on.on_next(675, 6), + on.on_next(700, 7), + on.on_completed(725) + }); + + WHEN("infinite retry is launched") { + + auto res = w.start( + [&]() { + return xs + .retry() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains all the data until complete") { + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(325, 2), + on.on_next(350, 3), + on.on_next(425, 1), + on.on_next(450, 2), + on.on_next(475, 3), + on.on_next(500, 4), + on.on_next(550, 1), + on.on_next(575, 2), + on.on_next(600, 3), + on.on_next(625, 4), + on.on_next(650, 5), + on.on_next(675, 6), + on.on_next(700, 7), + on.on_completed(725) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there were 3 subscriptions and 3 unsubscriptions to the ints") { + auto required = rxu::to_vector({ + on.subscribe(200, 400), + on.subscribe(400, 525), + on.subscribe(525, 725) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + + +SCENARIO("retry with failure", "[retry][operators]") { + GIVEN("hot observable of 3x4x7 ints with errors inbetween the groups. Retry 1. Must fail.") { + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + std::runtime_error ex("retry on_error from source"); + + auto xs = sc.make_hot_observable({ + on.on_next(300, 1), + on.on_next(325, 2), + on.on_next(350, 3), + on.on_error(400, ex), + on.on_next(425, 1), + on.on_next(450, 2), + on.on_next(475, 3), + on.on_next(500, 4), + on.on_error(525, ex), + on.on_next(550, 1), + on.on_next(575, 2), + on.on_next(600, 3), + on.on_next(625, 4), + on.on_next(650, 5), + on.on_next(675, 6), + on.on_next(700, 7), + on.on_completed(725) + }); + + WHEN("retry of 1 is launched with expected error before complete") { + + auto res = w.start( + [&]() { + return xs + .retry(1) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }); + + THEN("The output contains all the data until retry fails") { + auto required = rxu::to_vector({ + on.on_next(300, 1), + on.on_next(325, 2), + on.on_next(350, 3), + on.on_next(425, 1), + on.on_next(450, 2), + on.on_next(475, 3), + on.on_next(500, 4), + on.on_error(525, ex), + }); + auto actual = res.get_observer().messages(); + REQUIRE(actual == required); + } + + THEN("There were 2 subscriptions and 2 unsubscriptions to the ints") { + auto required = rxu::to_vector({ + on.subscribe(200, 400), + on.subscribe(400, 525) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + + -- GitLab From 2f45ae51b13ae3031e504448f09a42a22665b661 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Aug 2014 00:08:48 -0700 Subject: [PATCH 417/782] add retry tests --- projects/CMake/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 5ed89a9..0e71bc4 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -53,6 +53,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/repeat.cpp + ${TEST_DIR}/operators/retry.cpp ${TEST_DIR}/operators/scan.cpp ${TEST_DIR}/operators/skip.cpp ${TEST_DIR}/operators/skip_until.cpp -- GitLab From 4d90d99aba0d60a60b576433f1a99e1bd68d1236 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Aug 2014 23:56:39 -0700 Subject: [PATCH 418/782] wrong type specified in group_by --- Rx/v2/src/rxcpp/operators/rx-group_by.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp index 726d2da..dcba7ed 100644 --- a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp @@ -109,6 +109,7 @@ struct group_by { typedef group_by_observer this_type; typedef typename traits_type::grouped_observable_type value_type; + typedef typename traits_type::marble_type marble_type; typedef typename std::decay::type dest_type; typedef observer observer_type; dest_type dest; @@ -133,7 +134,7 @@ struct group_by if (g == groups.end()) { auto sub = subject_type(); g = groups.insert(std::make_pair(selectedKey.get(), sub.get_subscriber())).first; - dest.on_next(make_dynamic_grouped_observable(group_by_observable(sub, selectedKey.get()))); + dest.on_next(make_dynamic_grouped_observable(group_by_observable(sub, selectedKey.get()))); } auto selectedMarble = on_exception( [&](){ -- GitLab From 640884aa45ed9e1385ca8643c5e0b60a42c3ceee Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Aug 2014 23:56:59 -0700 Subject: [PATCH 419/782] wrong type for seed in scan --- Rx/v2/src/rxcpp/operators/rx-scan.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-scan.hpp b/Rx/v2/src/rxcpp/operators/rx-scan.hpp index 3776832..12c4b2f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-scan.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-scan.hpp @@ -39,7 +39,7 @@ struct scan : public operator_base::type> template static void check(...); - scan(source_type o, accumulator_type a, T s) + scan(source_type o, accumulator_type a, seed_type s) : initial(std::move(o), a, s) { static_assert(std::is_convertible(0)), seed_type>::value, "scan Accumulator must be a function with the signature Seed(Seed, T)"); -- GitLab From 40b186d6ac8ff3cf3580af3f7586ed9850221d58 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Aug 2014 23:57:22 -0700 Subject: [PATCH 420/782] ensure that maybe type is decayed --- Rx/v2/src/rxcpp/rx-observer.hpp | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 42741fc..6fad944 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -381,11 +381,22 @@ auto make_observer_dynamic(OnNext&& on, OnError&& oe, OnCompleted&& oc) dynamic_observer(make_observer(std::forward(on), std::forward(oe), std::forward(oc)))); } +namespace detail { + +template +struct maybe_from_result +{ + typedef decltype((*(F*)nullptr)()) decl_result_type; + typedef typename std::decay::type result_type; + typedef rxu::maybe type; +}; + +} template auto on_exception(const F& f, const OnError& c) - -> typename std::enable_if::value, rxu::detail::maybe>::type { - rxu::detail::maybe r; + -> typename std::enable_if::value, typename detail::maybe_from_result::type>::type { + typename detail::maybe_from_result::type r; try { r.reset(f()); } catch (...) { @@ -396,8 +407,8 @@ auto on_exception(const F& f, const OnError& c) template auto on_exception(const F& f, const Subscriber& s) - -> typename std::enable_if::value, rxu::detail::maybe>::type { - rxu::detail::maybe r; + -> typename std::enable_if::value, typename detail::maybe_from_result::type>::type { + typename detail::maybe_from_result::type r; try { r.reset(f()); } catch (...) { -- GitLab From ebfff78d8e64f67e8e58717c7780bb2f8a8733d2 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Aug 2014 23:57:50 -0700 Subject: [PATCH 421/782] a loop must prevent moves. --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index 4ead228..f94f8f9 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -149,7 +149,7 @@ public: } } template - void on_next(V&& v) const { + void on_next(V v) const { if (b->current_generation != b->state->generation) { std::unique_lock guard(b->state->lock); b->current_generation = b->state->generation; @@ -160,7 +160,7 @@ public: } for (auto& o : b->current_completer->observers) { if (o.is_subscribed()) { - o.on_next(std::forward(v)); + o.on_next(v); } } } -- GitLab From 4b6b5491d28e14b2caca95516bd5c06fd8956d3c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 27 Aug 2014 23:59:12 -0700 Subject: [PATCH 422/782] update tests to use on.next instead of on.on_next --- Rx/v2/examples/tests/main.cpp | 2 + Rx/v2/examples/tests/take.cpp | 105 ++++ Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 12 +- Rx/v2/test/operators/buffer.cpp | 188 +++---- Rx/v2/test/operators/combine_latest.1.cpp | 160 +++--- Rx/v2/test/operators/combine_latest.2.cpp | 168 +++--- Rx/v2/test/operators/concat.cpp | 76 +-- Rx/v2/test/operators/concat_map.cpp | 34 +- .../test/operators/distinct_until_changed.cpp | 94 ++-- Rx/v2/test/operators/filter.cpp | 182 +++--- Rx/v2/test/operators/flat_map.cpp | 156 +++--- Rx/v2/test/operators/group_by.cpp | 48 +- Rx/v2/test/operators/lift.cpp | 90 +-- Rx/v2/test/operators/map.cpp | 28 +- Rx/v2/test/operators/merge.cpp | 144 ++--- Rx/v2/test/operators/publish.cpp | 120 ++-- Rx/v2/test/operators/reduce.cpp | 32 +- Rx/v2/test/operators/repeat.cpp | 128 ++--- Rx/v2/test/operators/scan.cpp | 64 +-- Rx/v2/test/operators/skip.cpp | 486 ++++++++-------- Rx/v2/test/operators/skip_until.cpp | 130 ++--- Rx/v2/test/operators/switch_on_next.cpp | 200 +++---- Rx/v2/test/operators/take.cpp | 520 +++++++++--------- Rx/v2/test/operators/take_until.cpp | 202 +++---- Rx/v2/test/operators/window.cpp | 174 +++--- Rx/v2/test/sources/create.cpp | 4 +- Rx/v2/test/sources/defer.cpp | 8 +- Rx/v2/test/sources/scope.cpp | 58 +- Rx/v2/test/subjects/subject.cpp | 110 ++-- projects/CMake/CMakeLists.txt | 12 +- 30 files changed, 1925 insertions(+), 1810 deletions(-) create mode 100644 Rx/v2/examples/tests/main.cpp create mode 100644 Rx/v2/examples/tests/take.cpp diff --git a/Rx/v2/examples/tests/main.cpp b/Rx/v2/examples/tests/main.cpp new file mode 100644 index 0000000..0c7c351 --- /dev/null +++ b/Rx/v2/examples/tests/main.cpp @@ -0,0 +1,2 @@ +#define CATCH_CONFIG_MAIN +#include "catch.hpp" diff --git a/Rx/v2/examples/tests/take.cpp b/Rx/v2/examples/tests/take.cpp new file mode 100644 index 0000000..41ec184 --- /dev/null +++ b/Rx/v2/examples/tests/take.cpp @@ -0,0 +1,105 @@ +#include "rxcpp/rx.hpp" +namespace rx=rxcpp; +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("take 2 - passes", "[take][passes][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) + }); + + WHEN("2 values are taken"){ + + auto res = w.start( + [xs]() { + return xs + .take(2) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(220, 3), + on.completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} + +SCENARIO("take 2 - fails", "[take][fails][operators]"){ + GIVEN("a source"){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto xs = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) + }); + + WHEN("2 values are taken"){ + + auto res = w.start( + [xs]() { + return xs +// TYPO START + .skip(2) +// TYPO END + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output only contains items sent while subscribed"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(220, 3), + on.completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was 1 subscription/unsubscription to the source"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + } + } +} diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 068125a..ec77c40 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -398,9 +398,9 @@ public: } }; - static const on_next_factory on_next; - static const on_completed_factory on_completed; - static const on_error_factory on_error; + static const on_next_factory next; + static const on_completed_factory completed; + static const on_error_factory error; struct subscribe_factory { @@ -587,15 +587,15 @@ public: template //static -RXCPP_SELECT_ANY const typename test::messages::on_next_factory test::messages::on_next = test::messages::on_next_factory(); +RXCPP_SELECT_ANY const typename test::messages::on_next_factory test::messages::next = test::messages::on_next_factory(); template //static -RXCPP_SELECT_ANY const typename test::messages::on_completed_factory test::messages::on_completed = test::messages::on_completed_factory(); +RXCPP_SELECT_ANY const typename test::messages::on_completed_factory test::messages::completed = test::messages::on_completed_factory(); template //static -RXCPP_SELECT_ANY const typename test::messages::on_error_factory test::messages::on_error = test::messages::on_error_factory(); +RXCPP_SELECT_ANY const typename test::messages::on_error_factory test::messages::error = test::messages::on_error_factory(); template //static diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index f02d8fe..4a60877 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -14,12 +14,12 @@ SCENARIO("buffer count partial window", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("group each int with the next 4 ints"){ @@ -35,8 +35,8 @@ SCENARIO("buffer count partial window", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(250, rxu::to_vector({ 2, 3, 4, 5 })), - v_on.on_completed(250) + v_on.next(250, rxu::to_vector({ 2, 3, 4, 5 })), + v_on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -61,12 +61,12 @@ SCENARIO("buffer count full windows", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("group each int with the next int"){ @@ -82,9 +82,9 @@ SCENARIO("buffer count full windows", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(220, rxu::to_vector({ 2, 3 })), - v_on.on_next(240, rxu::to_vector({ 4, 5 })), - v_on.on_completed(250) + v_on.next(220, rxu::to_vector({ 2, 3 })), + v_on.next(240, rxu::to_vector({ 4, 5 })), + v_on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -109,12 +109,12 @@ SCENARIO("buffer count full and partial windows", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("group each int with the next 2 ints"){ @@ -130,9 +130,9 @@ SCENARIO("buffer count full and partial windows", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(230, rxu::to_vector({ 2, 3, 4 })), - v_on.on_next(250, rxu::to_vector({ 5 })), - v_on.on_completed(250) + v_on.next(230, rxu::to_vector({ 2, 3, 4 })), + v_on.next(250, rxu::to_vector({ 5 })), + v_on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -159,12 +159,12 @@ SCENARIO("buffer count error", "[buffer][operators]"){ std::runtime_error ex("buffer on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_error(250, ex) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.error(250, ex) }); WHEN("group each int with the next 4 ints"){ @@ -180,7 +180,7 @@ SCENARIO("buffer count error", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_error(250, ex) + v_on.error(250, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -205,12 +205,12 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("group each int with the next 2 ints"){ @@ -226,11 +226,11 @@ SCENARIO("buffer count skip less", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(230, rxu::to_vector({ 2, 3, 4 })), - v_on.on_next(240, rxu::to_vector({ 3, 4, 5 })), - v_on.on_next(250, rxu::to_vector({ 4, 5 })), - v_on.on_next(250, rxu::to_vector({ 5 })), - v_on.on_completed(250) + v_on.next(230, rxu::to_vector({ 2, 3, 4 })), + v_on.next(240, rxu::to_vector({ 3, 4, 5 })), + v_on.next(250, rxu::to_vector({ 4, 5 })), + v_on.next(250, rxu::to_vector({ 5 })), + v_on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -255,12 +255,12 @@ SCENARIO("buffer count skip more", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("group each int with the next int skipping the third one"){ @@ -276,9 +276,9 @@ SCENARIO("buffer count skip more", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(220, rxu::to_vector({ 2, 3 })), - v_on.on_next(250, rxu::to_vector({ 5 })), - v_on.on_completed(250) + v_on.next(220, rxu::to_vector({ 2, 3 })), + v_on.next(250, rxu::to_vector({ 5 })), + v_on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -303,16 +303,16 @@ SCENARIO("buffer count basic", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); WHEN("group each int with the next 2 ints"){ @@ -328,11 +328,11 @@ SCENARIO("buffer count basic", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(280, rxu::to_vector({ 2, 3, 4 })), - v_on.on_next(350, rxu::to_vector({ 4, 5, 6 })), - v_on.on_next(420, rxu::to_vector({ 6, 7, 8 })), - v_on.on_next(600, rxu::to_vector({ 8, 9 })), - v_on.on_completed(600) + v_on.next(280, rxu::to_vector({ 2, 3, 4 })), + v_on.next(350, rxu::to_vector({ 4, 5, 6 })), + v_on.next(420, rxu::to_vector({ 6, 7, 8 })), + v_on.next(600, rxu::to_vector({ 8, 9 })), + v_on.completed(600) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -357,16 +357,16 @@ SCENARIO("buffer count disposed", "[buffer][operators]"){ const rxsc::test::messages> v_on; auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); WHEN("group each int with the next 2 ints"){ @@ -383,8 +383,8 @@ SCENARIO("buffer count disposed", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(280, rxu::to_vector({ 2, 3, 4 })), - v_on.on_next(350, rxu::to_vector({ 4, 5, 6 })), + v_on.next(280, rxu::to_vector({ 2, 3, 4 })), + v_on.next(350, rxu::to_vector({ 4, 5, 6 })), }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -411,16 +411,16 @@ SCENARIO("buffer count error 2", "[buffer][operators]"){ std::runtime_error ex("buffer on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_error(600, ex) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) }); WHEN("group each int with the next 2 ints"){ @@ -436,10 +436,10 @@ SCENARIO("buffer count error 2", "[buffer][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.on_next(280, rxu::to_vector({ 2, 3, 4 })), - v_on.on_next(350, rxu::to_vector({ 4, 5, 6 })), - v_on.on_next(420, rxu::to_vector({ 6, 7, 8 })), - v_on.on_error(600, ex) + v_on.next(280, rxu::to_vector({ 2, 3, 4 })), + v_on.next(350, rxu::to_vector({ 4, 5, 6 })), + v_on.next(420, rxu::to_vector({ 6, 7, 8 })), + v_on.error(600, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/combine_latest.1.cpp b/Rx/v2/test/operators/combine_latest.1.cpp index acf2e93..0493c78 100644 --- a/Rx/v2/test/operators/combine_latest.1.cpp +++ b/Rx/v2/test/operators/combine_latest.1.cpp @@ -12,19 +12,19 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato const rxsc::test::messages on; auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_completed(230) + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.completed(230) }); auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(220, 3), - on.on_next(230, 5), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_completed(250) + on.next(150, 1), + on.next(220, 3), + on.next(230, 5), + on.next(235, 6), + on.next(240, 7), + on.completed(250) }); WHEN("each int is combined with the latest from the other source"){ @@ -45,12 +45,12 @@ SCENARIO("combine_latest interleaved with tail", "[combine_latest][join][operato THEN("the output contains combined ints"){ auto required = rxu::to_vector({ - on.on_next(220, 2 + 3), - on.on_next(225, 4 + 3), - on.on_next(230, 4 + 5), - on.on_next(235, 4 + 6), - on.on_next(240, 4 + 7), - on.on_completed(250) + on.next(220, 2 + 3), + on.next(225, 4 + 3), + on.next(230, 4 + 5), + on.next(235, 4 + 6), + on.next(240, 4 + 7), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -82,17 +82,17 @@ SCENARIO("combine_latest consecutive", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_completed(230) + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.completed(230) }); auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_completed(250) + on.next(150, 1), + on.next(235, 6), + on.next(240, 7), + on.completed(250) }); WHEN("each int is combined with the latest from the other source"){ @@ -113,9 +113,9 @@ SCENARIO("combine_latest consecutive", "[combine_latest][join][operators]"){ THEN("the output contains combined ints"){ auto required = rxu::to_vector({ - on.on_next(235, 4 + 6), - on.on_next(240, 4 + 7), - on.on_completed(250) + on.next(235, 4 + 6), + on.next(240, 4 + 7), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -149,17 +149,17 @@ SCENARIO("combine_latest consecutive ends with error left", "[combine_latest][jo std::runtime_error ex("combine_latest on_error from source"); auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_error(230, ex) + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.error(230, ex) }); auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_completed(250) + on.next(150, 1), + on.next(235, 6), + on.next(240, 7), + on.completed(250) }); WHEN("each int is combined with the latest from the other source"){ @@ -180,7 +180,7 @@ SCENARIO("combine_latest consecutive ends with error left", "[combine_latest][jo THEN("the output contains only an error"){ auto required = rxu::to_vector({ - on.on_error(230, ex) + on.error(230, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -214,17 +214,17 @@ SCENARIO("combine_latest consecutive ends with error right", "[combine_latest][j std::runtime_error ex("combine_latest on_error from source"); auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_next(225, 4), - on.on_completed(250) + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.completed(250) }); auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(235, 6), - on.on_next(240, 7), - on.on_error(245, ex) + on.next(150, 1), + on.next(235, 6), + on.next(240, 7), + on.error(245, ex) }); WHEN("each int is combined with the latest from the other source"){ @@ -245,9 +245,9 @@ SCENARIO("combine_latest consecutive ends with error right", "[combine_latest][j THEN("the output contains combined ints followed by an error"){ auto required = rxu::to_vector({ - on.on_next(235, 4 + 6), - on.on_next(240, 4 + 7), - on.on_error(245, ex) + on.next(235, 4 + 6), + on.next(240, 4 + 7), + on.error(245, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -284,7 +284,7 @@ SCENARIO("combine_latest never N", "[combine_latest][join][operators]"){ for (int i = 0; i < N; ++i) { n.push_back( sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }) ); } @@ -336,9 +336,9 @@ SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ std::vector> e; for (int i = 0; i < N; ++i) { e.push_back( - sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210 + 10 * i) + sc.make_hot_observable({ + on.next(150, 1), + on.completed(210 + 10 * i) }) ); } @@ -350,7 +350,7 @@ SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ return e[0] .combine_latest( [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ - return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; }, e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] ) @@ -361,14 +361,14 @@ SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ THEN("the output contains only complete message"){ auto required = rxu::to_vector({ - on.on_completed(200 + 10 * N) + on.completed(200 + 10 * N) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } THEN("there was one subscription and one unsubscription to each observable"){ - + int i = 0; std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ auto required = rxu::to_vector({ @@ -389,12 +389,12 @@ SCENARIO("combine_latest never/empty", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto n = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) + on.next(150, 1), + on.completed(210) }); WHEN("each int is combined with the latest from the other source"){ @@ -445,12 +445,12 @@ SCENARIO("combine_latest empty/never", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) + on.next(150, 1), + on.completed(210) }); auto n = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("each int is combined with the latest from the other source"){ @@ -501,14 +501,14 @@ SCENARIO("combine_latest empty/return", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) + on.next(150, 1), + on.completed(210) }); auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) + on.next(150, 1), + on.next(215, 2), + on.completed(220) }); WHEN("each int is combined with the latest from the other source"){ @@ -529,7 +529,7 @@ SCENARIO("combine_latest empty/return", "[combine_latest][join][operators]"){ THEN("the output contains only complete message"){ auto required = rxu::to_vector({ - on.on_completed(220) + on.completed(220) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -561,14 +561,14 @@ SCENARIO("combine_latest return/empty", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) + on.next(150, 1), + on.next(215, 2), + on.completed(220) }); auto e = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(210) + on.next(150, 1), + on.completed(210) }); WHEN("each int is combined with the latest from the other source"){ @@ -589,7 +589,7 @@ SCENARIO("combine_latest return/empty", "[combine_latest][join][operators]"){ THEN("the output contains only complete message"){ auto required = rxu::to_vector({ - on.on_completed(220) + on.completed(220) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -621,13 +621,13 @@ SCENARIO("combine_latest never/return", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto n = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) + on.next(150, 1), + on.next(215, 2), + on.completed(220) }); WHEN("each int is combined with the latest from the other source"){ @@ -678,13 +678,13 @@ SCENARIO("combine_latest return/never", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(220) + on.next(150, 1), + on.next(215, 2), + on.completed(220) }); auto n = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("each int is combined with the latest from the other source"){ diff --git a/Rx/v2/test/operators/combine_latest.2.cpp b/Rx/v2/test/operators/combine_latest.2.cpp index 4e26fcc..7406a26 100644 --- a/Rx/v2/test/operators/combine_latest.2.cpp +++ b/Rx/v2/test/operators/combine_latest.2.cpp @@ -12,15 +12,15 @@ SCENARIO("combine_latest return/return", "[combine_latest][join][operators]"){ const rxsc::test::messages on; auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(230) + on.next(150, 1), + on.next(215, 2), + on.completed(230) }); auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(220, 3), - on.on_completed(240) + on.next(150, 1), + on.next(220, 3), + on.completed(240) }); WHEN("each int is combined with the latest from the other source"){ @@ -41,8 +41,8 @@ SCENARIO("combine_latest return/return", "[combine_latest][join][operators]"){ THEN("the output contains combined ints"){ auto required = rxu::to_vector({ - on.on_next(220, 2 + 3), - on.on_completed(240) + on.next(220, 2 + 3), + on.completed(240) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -76,13 +76,13 @@ SCENARIO("combine_latest empty/error", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto emp = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(230) + on.next(150, 1), + on.completed(230) }); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); WHEN("each int is combined with the latest from the other source"){ @@ -103,7 +103,7 @@ SCENARIO("combine_latest empty/error", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -137,13 +137,13 @@ SCENARIO("combine_latest error/empty", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); auto emp = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(230) + on.next(150, 1), + on.completed(230) }); WHEN("each int is combined with the latest from the other source"){ @@ -164,7 +164,7 @@ SCENARIO("combine_latest error/empty", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -198,14 +198,14 @@ SCENARIO("combine_latest return/error", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto o = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_completed(230) + on.next(150, 1), + on.next(210, 2), + on.completed(230) }); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); WHEN("each int is combined with the latest from the other source"){ @@ -226,7 +226,7 @@ SCENARIO("combine_latest return/error", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -260,14 +260,14 @@ SCENARIO("combine_latest error/return", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); auto ret = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_completed(230) + on.next(150, 1), + on.next(210, 2), + on.completed(230) }); WHEN("each int is combined with the latest from the other source"){ @@ -288,7 +288,7 @@ SCENARIO("combine_latest error/return", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -323,13 +323,13 @@ SCENARIO("combine_latest error/error", "[combine_latest][join][operators]"){ std::runtime_error ex2("combine_latest on_error from source 2"); auto err1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex1) + on.next(150, 1), + on.error(220, ex1) }); auto err2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(230, ex2) + on.next(150, 1), + on.error(230, ex2) }); WHEN("each int is combined with the latest from the other source"){ @@ -350,7 +350,7 @@ SCENARIO("combine_latest error/error", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex1) + on.error(220, ex1) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -385,14 +385,14 @@ SCENARIO("combine_latest next+error/error", "[combine_latest][join][operators]") std::runtime_error ex2("combine_latest on_error from source 2"); auto err1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_error(220, ex1) + on.next(150, 1), + on.next(210, 2), + on.error(220, ex1) }); auto err2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(230, ex2) + on.next(150, 1), + on.error(230, ex2) }); WHEN("each int is combined with the latest from the other source"){ @@ -413,7 +413,7 @@ SCENARIO("combine_latest next+error/error", "[combine_latest][join][operators]") THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex1) + on.error(220, ex1) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -448,14 +448,14 @@ SCENARIO("combine_latest error/next+error", "[combine_latest][join][operators]") std::runtime_error ex2("combine_latest on_error from source 2"); auto err1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(230, ex1) + on.next(150, 1), + on.error(230, ex1) }); auto err2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_error(220, ex2) + on.next(150, 1), + on.next(210, 2), + on.error(220, ex2) }); WHEN("each int is combined with the latest from the other source"){ @@ -476,7 +476,7 @@ SCENARIO("combine_latest error/next+error", "[combine_latest][join][operators]") THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex2) + on.error(220, ex2) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -510,12 +510,12 @@ SCENARIO("combine_latest never/error", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto n = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); WHEN("each int is combined with the latest from the other source"){ @@ -536,7 +536,7 @@ SCENARIO("combine_latest never/error", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -570,12 +570,12 @@ SCENARIO("combine_latest error/never", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); auto n = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("each int is combined with the latest from the other source"){ @@ -596,7 +596,7 @@ SCENARIO("combine_latest error/never", "[combine_latest][join][operators]"){ THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -630,14 +630,14 @@ SCENARIO("combine_latest error after completed left", "[combine_latest][join][op std::runtime_error ex("combine_latest on_error from source"); auto ret = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_completed(215) + on.next(150, 1), + on.next(210, 2), + on.completed(215) }); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); WHEN("each int is combined with the latest from the other source"){ @@ -658,7 +658,7 @@ SCENARIO("combine_latest error after completed left", "[combine_latest][join][op THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -692,14 +692,14 @@ SCENARIO("combine_latest error after completed right", "[combine_latest][join][o std::runtime_error ex("combine_latest on_error from source"); auto err = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(220, ex) + on.next(150, 1), + on.error(220, ex) }); auto ret = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_completed(215) + on.next(150, 1), + on.next(210, 2), + on.completed(215) }); WHEN("each int is combined with the latest from the other source"){ @@ -720,7 +720,7 @@ SCENARIO("combine_latest error after completed right", "[combine_latest][join][o THEN("the output contains only error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -754,15 +754,15 @@ SCENARIO("combine_latest selector throws", "[combine_latest][join][operators]"){ std::runtime_error ex("combine_latest on_error from source"); auto o1 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(215, 2), - on.on_completed(230) + on.next(150, 1), + on.next(215, 2), + on.completed(230) }); auto o2 = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(220, 3), - on.on_completed(240) + on.next(150, 1), + on.next(220, 3), + on.completed(240) }); WHEN("each int is combined with the latest from the other source"){ @@ -783,7 +783,7 @@ SCENARIO("combine_latest selector throws", "[combine_latest][join][operators]"){ THEN("the output contains only error"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -822,8 +822,8 @@ SCENARIO("combine_latest selector throws N", "[combine_latest][join][operators]" for (int i = 0; i < N; ++i) { e.push_back( sc.make_hot_observable({ - on.on_next(210 + 10 * i, 1), - on.on_completed(500) + on.next(210 + 10 * i, 1), + on.completed(500) }) ); } @@ -846,7 +846,7 @@ SCENARIO("combine_latest selector throws N", "[combine_latest][join][operators]" THEN("the output contains only error"){ auto required = rxu::to_vector({ - on.on_error(200 + 10 * N, ex) + on.error(200 + 10 * N, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -878,10 +878,10 @@ SCENARIO("combine_latest typical N", "[combine_latest][join][operators]"){ for (int i = 0; i < N; ++i) { o.push_back( sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210 + 10 * i, i + 1), - on.on_next(410 + 10 * i, i + N + 1), - on.on_completed(800) + on.next(150, 1), + on.next(210 + 10 * i, i + 1), + on.next(410 + 10 * i, i + N + 1), + on.completed(800) }) ); } @@ -904,12 +904,12 @@ SCENARIO("combine_latest typical N", "[combine_latest][join][operators]"){ THEN("the output contains combined ints"){ auto required = rxu::to_vector({ - on.on_next(200 + 10 * N, N * (N + 1) / 2) + on.next(200 + 10 * N, N * (N + 1) / 2) }); for (int i = 0; i < N; ++i) { - required.push_back(on.on_next(410 + 10 * i, N * (N + 1) / 2 + N + N * i)); + required.push_back(on.next(410 + 10 * i, N * (N + 1) / 2 + N + N * i)); } - required.push_back(on.on_completed(800)); + required.push_back(on.completed(800)); auto actual = res.get_observer().messages(); REQUIRE(required == actual); } diff --git a/Rx/v2/test/operators/concat.cpp b/Rx/v2/test/operators/concat.cpp index 91be2be..f37ec24 100644 --- a/Rx/v2/test/operators/concat.cpp +++ b/Rx/v2/test/operators/concat.cpp @@ -102,37 +102,37 @@ SCENARIO("concat completes", "[concat][join][operators]"){ const rxsc::test::messages> o_on; auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto ys2 = sc.make_cold_observable({ - on.on_next(10, 201), - on.on_next(20, 202), - on.on_next(30, 203), - on.on_next(40, 204), - on.on_completed(50) + on.next(10, 201), + on.next(20, 202), + on.next(30, 203), + on.next(40, 204), + on.completed(50) }); auto ys3 = sc.make_cold_observable({ - on.on_next(10, 301), - on.on_next(20, 302), - on.on_next(30, 303), - on.on_next(40, 304), - on.on_next(120, 305), - on.on_completed(150) + on.next(10, 301), + on.next(20, 302), + on.next(30, 303), + on.next(40, 304), + on.next(120, 305), + on.completed(150) }); auto xs = sc.make_hot_observable({ - o_on.on_next(300, ys1), - o_on.on_next(400, ys2), - o_on.on_next(500, ys3), - o_on.on_completed(600) + o_on.next(300, ys1), + o_on.next(400, ys2), + o_on.next(500, ys3), + o_on.completed(600) }); WHEN("each int is merged"){ @@ -148,22 +148,22 @@ SCENARIO("concat completes", "[concat][join][operators]"){ THEN("the output contains merged ints"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 103), - on.on_next(420, 104), - on.on_next(510, 105), - on.on_next(520, 106), - on.on_next(540, 201), - on.on_next(550, 202), - on.on_next(560, 203), - on.on_next(570, 204), - on.on_next(590, 301), - on.on_next(600, 302), - on.on_next(610, 303), - on.on_next(620, 304), - on.on_next(700, 305), - on.on_completed(730) + on.next(310, 101), + on.next(320, 102), + on.next(410, 103), + on.next(420, 104), + on.next(510, 105), + on.next(520, 106), + on.next(540, 201), + on.next(550, 202), + on.next(560, 203), + on.next(570, 204), + on.next(590, 301), + on.next(600, 302), + on.next(610, 303), + on.next(620, 304), + on.next(700, 305), + on.completed(730) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 7dc1302..0d3402c 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -208,17 +208,17 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ const rxsc::test::messages s_on; auto xs = sc.make_cold_observable({ - i_on.on_next(100, 4), - i_on.on_next(200, 2), - i_on.on_completed(500) + i_on.next(100, 4), + i_on.next(200, 2), + i_on.completed(500) }); auto ys = sc.make_cold_observable({ - s_on.on_next(50, "foo"), - s_on.on_next(100, "bar"), - s_on.on_next(150, "baz"), - s_on.on_next(200, "qux"), - s_on.on_completed(250) + s_on.next(50, "foo"), + s_on.next(100, "bar"), + s_on.next(150, "baz"), + s_on.next(200, "qux"), + s_on.completed(250) }); WHEN("each int is mapped to the strings"){ @@ -238,15 +238,15 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ THEN("the output contains strings repeated for each int"){ auto required = rxu::to_vector({ - s_on.on_next(350, "foo"), - s_on.on_next(400, "bar"), - s_on.on_next(450, "baz"), - s_on.on_next(500, "qux"), - s_on.on_next(600, "foo"), - s_on.on_next(650, "bar"), - s_on.on_next(700, "baz"), - s_on.on_next(750, "qux"), - s_on.on_completed(800) + s_on.next(350, "foo"), + s_on.next(400, "bar"), + s_on.next(450, "baz"), + s_on.next(500, "qux"), + s_on.next(600, "foo"), + s_on.next(650, "bar"), + s_on.next(700, "baz"), + s_on.next(750, "qux"), + s_on.completed(800) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/distinct_until_changed.cpp b/Rx/v2/test/operators/distinct_until_changed.cpp index 150b086..cf8d5cf 100644 --- a/Rx/v2/test/operators/distinct_until_changed.cpp +++ b/Rx/v2/test/operators/distinct_until_changed.cpp @@ -12,7 +12,7 @@ SCENARIO("distinct_until_changed - never", "[distinct_until_changed][operators]" const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("distinct values are taken"){ @@ -47,8 +47,8 @@ SCENARIO("distinct_until_changed - empty", "[distinct_until_changed][operators]" const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(250) + on.next(150, 1), + on.completed(250) }); WHEN("distinct values are taken"){ @@ -61,7 +61,7 @@ SCENARIO("distinct_until_changed - empty", "[distinct_until_changed][operators]" THEN("the output only contains complete message"){ auto required = rxu::to_vector({ - on.on_completed(250) + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -86,9 +86,9 @@ SCENARIO("distinct_until_changed - return", "[distinct_until_changed][operators] const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.completed(250) }); WHEN("distinct values are taken"){ @@ -101,8 +101,8 @@ SCENARIO("distinct_until_changed - return", "[distinct_until_changed][operators] THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_completed(250) + on.next(210, 2), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -127,10 +127,10 @@ SCENARIO("distinct_until_changed - throw", "[distinct_until_changed][operators]" const rxsc::test::messages on; std::runtime_error ex("distinct_until_changed on_error from source"); - + auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(250, ex) + on.next(150, 1), + on.error(250, ex) }); WHEN("distinct values are taken"){ @@ -143,7 +143,7 @@ SCENARIO("distinct_until_changed - throw", "[distinct_until_changed][operators]" THEN("the output only contains only error"){ auto required = rxu::to_vector({ - on.on_error(250, ex) + on.error(250, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -168,12 +168,12 @@ SCENARIO("distinct_until_changed - all changes", "[distinct_until_changed][opera const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("distinct values are taken"){ @@ -186,11 +186,11 @@ SCENARIO("distinct_until_changed - all changes", "[distinct_until_changed][opera THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -215,12 +215,12 @@ SCENARIO("distinct_until_changed - all same", "[distinct_until_changed][operator const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 2), - on.on_next(230, 2), - on.on_next(240, 2), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 2), + on.next(230, 2), + on.next(240, 2), + on.completed(250) }); WHEN("distinct values are taken"){ @@ -233,8 +233,8 @@ SCENARIO("distinct_until_changed - all same", "[distinct_until_changed][operator THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_completed(250) + on.next(210, 2), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -259,15 +259,15 @@ SCENARIO("distinct_until_changed - some changes", "[distinct_until_changed][oper const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), //* - on.on_next(215, 3), //* - on.on_next(220, 3), - on.on_next(225, 2), //* - on.on_next(230, 2), - on.on_next(230, 1), //* - on.on_next(240, 2), //* - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), //* + on.next(215, 3), //* + on.next(220, 3), + on.next(225, 2), //* + on.next(230, 2), + on.next(230, 1), //* + on.next(240, 2), //* + on.completed(250) }); WHEN("distinct values are taken"){ @@ -280,12 +280,12 @@ SCENARIO("distinct_until_changed - some changes", "[distinct_until_changed][oper THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), //* - on.on_next(215, 3), //* - on.on_next(225, 2), //* - on.on_next(230, 1), //* - on.on_next(240, 2), //* - on.on_completed(250) + on.next(210, 2), //* + on.next(215, 3), //* + on.next(225, 2), //* + on.next(230, 1), //* + on.next(240, 2), //* + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index 529f10a..fdab02a 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -31,21 +31,21 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600), - on.on_next(610, 12), - on.on_error(620, std::runtime_error("error in unsubscribed stream")), - on.on_completed(630) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600), + on.next(610, 12), + on.error(620, std::runtime_error("error in unsubscribed stream")), + on.completed(630) }); WHEN("filtered to ints that are primes"){ @@ -76,11 +76,11 @@ SCENARIO("filter stops on completion", "[filter][operators]"){ ); THEN("the output only contains primes"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7), - on.on_next(580, 11), - on.on_completed(600) + on.next(230, 3), + on.next(340, 5), + on.next(390, 7), + on.next(580, 11), + on.completed(600) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -111,18 +111,18 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600) }); WHEN("filtered to ints that are primes"){ @@ -152,9 +152,9 @@ SCENARIO("filter stops on disposal", "[where][filter][operators]"){ THEN("the output only contains primes that arrived before disposal"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7) + on.next(230, 3), + on.next(340, 5), + on.next(390, 7) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -186,21 +186,21 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ std::runtime_error ex("filter on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_error(600, ex), - on.on_next(610, 12), - on.on_error(620, std::runtime_error("error in unsubscribed stream")), - on.on_completed(630) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.error(600, ex), + on.next(610, 12), + on.error(620, std::runtime_error("error in unsubscribed stream")), + on.completed(630) }); WHEN("filtered to ints that are primes"){ @@ -229,11 +229,11 @@ SCENARIO("filter stops on error", "[where][filter][operators]"){ THEN("the output only contains primes"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7), - on.on_next(580, 11), - on.on_error(600, ex), + on.next(230, 3), + on.next(340, 5), + on.next(390, 7), + on.next(580, 11), + on.error(600, ex), }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -265,21 +265,21 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ std::runtime_error ex("filter predicate error"); auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600), - on.on_next(610, 12), - on.on_error(620, std::runtime_error("error in unsubscribed stream")), - on.on_completed(630) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600), + on.next(610, 12), + on.error(620, std::runtime_error("error in unsubscribed stream")), + on.completed(630) }); WHEN("filtered to ints that are primes"){ @@ -314,9 +314,9 @@ SCENARIO("filter stops on throw from predicate", "[where][filter][operators]"){ THEN("the output only contains primes"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_error(380, ex) + on.next(230, 3), + on.next(340, 5), + on.error(380, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -346,21 +346,21 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600), - on.on_next(610, 12), - on.on_error(620, std::exception()), - on.on_completed(630) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600), + on.next(610, 12), + on.error(620, std::exception()), + on.completed(630) }); auto res = w.make_subscriber(); @@ -402,9 +402,9 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") THEN("the output only contains primes"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7) + on.next(230, 3), + on.next(340, 5), + on.next(390, 7) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 9f99055..8490de8 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -242,19 +242,19 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ const rxsc::test::messages s_on; auto xs = sc.make_cold_observable({ - i_on.on_next(100, 4), - i_on.on_next(200, 2), - i_on.on_next(300, 3), - i_on.on_next(400, 1), - i_on.on_completed(500) + i_on.next(100, 4), + i_on.next(200, 2), + i_on.next(300, 3), + i_on.next(400, 1), + i_on.completed(500) }); auto ys = sc.make_cold_observable({ - s_on.on_next(50, "foo"), - s_on.on_next(100, "bar"), - s_on.on_next(150, "baz"), - s_on.on_next(200, "qux"), - s_on.on_completed(250) + s_on.next(50, "foo"), + s_on.next(100, "bar"), + s_on.next(150, "baz"), + s_on.next(200, "qux"), + s_on.completed(250) }); WHEN("each int is mapped to the strings"){ @@ -274,23 +274,23 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ THEN("the output contains strings repeated for each int"){ auto required = rxu::to_vector({ - s_on.on_next(350, "foo"), - s_on.on_next(400, "bar"), - s_on.on_next(450, "baz"), - s_on.on_next(450, "foo"), - s_on.on_next(500, "qux"), - s_on.on_next(500, "bar"), - s_on.on_next(550, "baz"), - s_on.on_next(550, "foo"), - s_on.on_next(600, "qux"), - s_on.on_next(600, "bar"), - s_on.on_next(650, "baz"), - s_on.on_next(650, "foo"), - s_on.on_next(700, "qux"), - s_on.on_next(700, "bar"), - s_on.on_next(750, "baz"), - s_on.on_next(800, "qux"), - s_on.on_completed(850) + s_on.next(350, "foo"), + s_on.next(400, "bar"), + s_on.next(450, "baz"), + s_on.next(450, "foo"), + s_on.next(500, "qux"), + s_on.next(500, "bar"), + s_on.next(550, "baz"), + s_on.next(550, "foo"), + s_on.next(600, "qux"), + s_on.next(600, "bar"), + s_on.next(650, "baz"), + s_on.next(650, "foo"), + s_on.next(700, "qux"), + s_on.next(700, "bar"), + s_on.next(750, "baz"), + s_on.next(800, "qux"), + s_on.completed(850) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -327,20 +327,20 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ const rxsc::test::messages s_on; auto xs = sc.make_cold_observable({ - i_on.on_next(100, 4), - i_on.on_next(200, 2), - i_on.on_next(300, 3), - i_on.on_next(400, 1), - i_on.on_next(500, 5), - i_on.on_next(700, 0) + i_on.next(100, 4), + i_on.next(200, 2), + i_on.next(300, 3), + i_on.next(400, 1), + i_on.next(500, 5), + i_on.next(700, 0) }); auto ys = sc.make_cold_observable({ - s_on.on_next(50, "foo"), - s_on.on_next(100, "bar"), - s_on.on_next(150, "baz"), - s_on.on_next(200, "qux"), - s_on.on_completed(250) + s_on.next(50, "foo"), + s_on.next(100, "bar"), + s_on.next(150, "baz"), + s_on.next(200, "qux"), + s_on.completed(250) }); WHEN("each int is mapped to the strings"){ @@ -356,27 +356,27 @@ SCENARIO("flat_map source never ends", "[flat_map][map][operators]"){ THEN("the output contains strings repeated for each int"){ auto required = rxu::to_vector({ - s_on.on_next(350, "foo"), - s_on.on_next(400, "bar"), - s_on.on_next(450, "baz"), - s_on.on_next(450, "foo"), - s_on.on_next(500, "qux"), - s_on.on_next(500, "bar"), - s_on.on_next(550, "baz"), - s_on.on_next(550, "foo"), - s_on.on_next(600, "qux"), - s_on.on_next(600, "bar"), - s_on.on_next(650, "baz"), - s_on.on_next(650, "foo"), - s_on.on_next(700, "qux"), - s_on.on_next(700, "bar"), - s_on.on_next(750, "baz"), - s_on.on_next(750, "foo"), - s_on.on_next(800, "qux"), - s_on.on_next(800, "bar"), - s_on.on_next(850, "baz"), - s_on.on_next(900, "qux"), - s_on.on_next(950, "foo") + s_on.next(350, "foo"), + s_on.next(400, "bar"), + s_on.next(450, "baz"), + s_on.next(450, "foo"), + s_on.next(500, "qux"), + s_on.next(500, "bar"), + s_on.next(550, "baz"), + s_on.next(550, "foo"), + s_on.next(600, "qux"), + s_on.next(600, "bar"), + s_on.next(650, "baz"), + s_on.next(650, "foo"), + s_on.next(700, "qux"), + s_on.next(700, "bar"), + s_on.next(750, "baz"), + s_on.next(750, "foo"), + s_on.next(800, "qux"), + s_on.next(800, "bar"), + s_on.next(850, "baz"), + s_on.next(900, "qux"), + s_on.next(950, "foo") }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -414,21 +414,21 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ const rxsc::test::messages s_on; auto xs = sc.make_cold_observable({ - i_on.on_next(100, 4), - i_on.on_next(200, 2), - i_on.on_next(300, 3), - i_on.on_next(400, 1), - i_on.on_completed(500) + i_on.next(100, 4), + i_on.next(200, 2), + i_on.next(300, 3), + i_on.next(400, 1), + i_on.completed(500) }); std::runtime_error ex("filter on_error from inner source"); auto ys = sc.make_cold_observable({ - s_on.on_next(55, "foo"), - s_on.on_next(104, "bar"), - s_on.on_next(153, "baz"), - s_on.on_next(202, "qux"), - s_on.on_error(301, ex) + s_on.next(55, "foo"), + s_on.next(104, "bar"), + s_on.next(153, "baz"), + s_on.next(202, "qux"), + s_on.error(301, ex) }); WHEN("each int is mapped to the strings"){ @@ -444,15 +444,15 @@ SCENARIO("flat_map inner error", "[flat_map][map][operators]"){ THEN("the output contains strings repeated for each int"){ auto required = rxu::to_vector({ - s_on.on_next(355, "foo"), - s_on.on_next(404, "bar"), - s_on.on_next(453, "baz"), - s_on.on_next(455, "foo"), - s_on.on_next(502, "qux"), - s_on.on_next(504, "bar"), - s_on.on_next(553, "baz"), - s_on.on_next(555, "foo"), - s_on.on_error(601, ex) + s_on.next(355, "foo"), + s_on.next(404, "bar"), + s_on.next(453, "baz"), + s_on.next(455, "foo"), + s_on.next(502, "qux"), + s_on.next(504, "bar"), + s_on.next(553, "baz"), + s_on.next(555, "foo"), + s_on.error(601, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index 1d85193..674c54a 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -166,25 +166,25 @@ SCENARIO("group_by", "[group_by][operators]"){ int marbleInvoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(90, "error"), - on.on_next(110, "error"), - on.on_next(130, "error"), - on.on_next(220, " foo"), - on.on_next(240, " FoO "), - on.on_next(270, "baR "), - on.on_next(310, "foO "), - on.on_next(350, " Baz "), - on.on_next(360, " qux "), - on.on_next(390, " bar"), - on.on_next(420, " BAR "), - on.on_next(470, "FOO "), - on.on_next(480, "baz "), - on.on_next(510, " bAZ "), - on.on_next(530, " fOo "), - on.on_completed(570), - on.on_next(580, "error"), - on.on_completed(600), - on.on_error(650, new std::runtime_error("error in completed sequence")) + on.next(90, "error"), + on.next(110, "error"), + on.next(130, "error"), + on.next(220, " foo"), + on.next(240, " FoO "), + on.next(270, "baR "), + on.next(310, "foO "), + on.next(350, " Baz "), + on.next(360, " qux "), + on.next(390, " bar"), + on.next(420, " BAR "), + on.next(470, "FOO "), + on.next(480, "baz "), + on.next(510, " bAZ "), + on.next(530, " fOo "), + on.completed(570), + on.next(580, "error"), + on.completed(600), + on.error(650, new std::runtime_error("error in completed sequence")) }); WHEN("group each int with the next 2 ints"){ @@ -211,11 +211,11 @@ SCENARIO("group_by", "[group_by][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - on.on_next(220, "foo"), - on.on_next(270, "baR"), - on.on_next(350, "Baz"), - on.on_next(360, "qux"), - on.on_completed(570) + on.next(220, "foo"), + on.next(270, "baR"), + on.next(350, "Baz"), + on.next(360, "qux"), + on.completed(570) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/lift.cpp b/Rx/v2/test/operators/lift.cpp index 0496019..0794178 100644 --- a/Rx/v2/test/operators/lift.cpp +++ b/Rx/v2/test/operators/lift.cpp @@ -101,18 +101,18 @@ SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]" long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600) }); WHEN("filtered to ints that are primes"){ @@ -132,9 +132,9 @@ SCENARIO("lift liftfilter stops on disposal", "[where][filter][lift][operators]" THEN("the output only contains primes that arrived before disposal"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7) + on.next(230, 3), + on.next(340, 5), + on.next(390, 7) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -164,18 +164,18 @@ SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][stre long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600) }); WHEN("filtered to ints that are primes"){ @@ -195,9 +195,9 @@ SCENARIO("stream lift liftfilter stops on disposal", "[where][filter][lift][stre THEN("the output only contains primes that arrived before disposal"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7) + on.next(230, 3), + on.next(340, 5), + on.next(390, 7) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -227,18 +227,18 @@ SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][ long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(110, 1), - on.on_next(180, 2), - on.on_next(230, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(380, 6), - on.on_next(390, 7), - on.on_next(450, 8), - on.on_next(470, 9), - on.on_next(560, 10), - on.on_next(580, 11), - on.on_completed(600) + on.next(110, 1), + on.next(180, 2), + on.next(230, 3), + on.next(270, 4), + on.next(340, 5), + on.next(380, 6), + on.next(390, 7), + on.next(450, 8), + on.next(470, 9), + on.next(560, 10), + on.next(580, 11), + on.completed(600) }); WHEN("filtered to ints that are primes"){ @@ -271,9 +271,9 @@ SCENARIO("lift lambda filter stops on disposal", "[where][filter][lift][lambda][ THEN("the output only contains primes that arrived before disposal"){ auto required = rxu::to_vector({ - on.on_next(230, 3), - on.on_next(340, 5), - on.on_next(390, 7) + on.next(230, 3), + on.next(340, 5), + on.next(390, 7) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/map.cpp b/Rx/v2/test/operators/map.cpp index 4491511..aab227f 100644 --- a/Rx/v2/test/operators/map.cpp +++ b/Rx/v2/test/operators/map.cpp @@ -13,15 +13,15 @@ SCENARIO("map stops on completion", "[map][operators]"){ long invoked = 0; auto xs = sc.make_hot_observable({ - on.on_next(180, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(290, 4), - on.on_next(350, 5), - on.on_completed(400), - on.on_next(410, -1), - on.on_completed(420), - on.on_error(430, std::runtime_error("error on unsubscribed stream")) + on.next(180, 1), + on.next(210, 2), + on.next(240, 3), + on.next(290, 4), + on.next(350, 5), + on.completed(400), + on.next(410, -1), + on.completed(420), + on.error(430, std::runtime_error("error on unsubscribed stream")) }); WHEN("mapped to ints that are one larger"){ @@ -40,11 +40,11 @@ SCENARIO("map stops on completion", "[map][operators]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(210, 3), - on.on_next(240, 4), - on.on_next(290, 5), - on.on_next(350, 6), - on.on_completed(400) + on.next(210, 3), + on.next(240, 4), + on.next(290, 5), + on.next(350, 6), + on.completed(400) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/merge.cpp b/Rx/v2/test/operators/merge.cpp index a8a32ad..2b32838 100644 --- a/Rx/v2/test/operators/merge.cpp +++ b/Rx/v2/test/operators/merge.cpp @@ -102,37 +102,37 @@ SCENARIO("merge completes", "[merge][join][operators]"){ const rxsc::test::messages> o_on; auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto ys2 = sc.make_cold_observable({ - on.on_next(10, 201), - on.on_next(20, 202), - on.on_next(30, 203), - on.on_next(40, 204), - on.on_completed(50) + on.next(10, 201), + on.next(20, 202), + on.next(30, 203), + on.next(40, 204), + on.completed(50) }); auto ys3 = sc.make_cold_observable({ - on.on_next(10, 301), - on.on_next(20, 302), - on.on_next(30, 303), - on.on_next(40, 304), - on.on_next(120, 305), - on.on_completed(150) + on.next(10, 301), + on.next(20, 302), + on.next(30, 303), + on.next(40, 304), + on.next(120, 305), + on.completed(150) }); auto xs = sc.make_hot_observable({ - o_on.on_next(300, ys1), - o_on.on_next(400, ys2), - o_on.on_next(500, ys3), - o_on.on_completed(600) + o_on.next(300, ys1), + o_on.next(400, ys2), + o_on.next(500, ys3), + o_on.completed(600) }); WHEN("each int is merged"){ @@ -148,22 +148,22 @@ SCENARIO("merge completes", "[merge][join][operators]"){ THEN("the output contains merged ints"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 103), - on.on_next(410, 201), - on.on_next(420, 104), - on.on_next(420, 202), - on.on_next(430, 203), - on.on_next(440, 204), - on.on_next(510, 105), - on.on_next(510, 301), - on.on_next(520, 106), - on.on_next(520, 302), - on.on_next(530, 303), - on.on_next(540, 304), - on.on_next(620, 305), - on.on_completed(650) + on.next(310, 101), + on.next(320, 102), + on.next(410, 103), + on.next(410, 201), + on.next(420, 104), + on.next(420, 202), + on.next(430, 203), + on.next(440, 204), + on.next(510, 105), + on.next(510, 301), + on.next(520, 106), + on.next(520, 302), + on.next(530, 303), + on.next(540, 304), + on.next(620, 305), + on.completed(650) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -212,30 +212,30 @@ SCENARIO("variadic merge completes", "[merge][join][operators]"){ const rxsc::test::messages> o_on; auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto ys2 = sc.make_cold_observable({ - on.on_next(10, 201), - on.on_next(20, 202), - on.on_next(30, 203), - on.on_next(40, 204), - on.on_completed(50) + on.next(10, 201), + on.next(20, 202), + on.next(30, 203), + on.next(40, 204), + on.completed(50) }); auto ys3 = sc.make_cold_observable({ - on.on_next(10, 301), - on.on_next(20, 302), - on.on_next(30, 303), - on.on_next(40, 304), - on.on_next(120, 305), - on.on_completed(150) + on.next(10, 301), + on.next(20, 302), + on.next(30, 303), + on.next(40, 304), + on.next(120, 305), + on.completed(150) }); WHEN("each int is merged"){ @@ -249,22 +249,22 @@ SCENARIO("variadic merge completes", "[merge][join][operators]"){ THEN("the output contains merged ints"){ auto required = rxu::to_vector({ - on.on_next(210, 101), - on.on_next(210, 201), - on.on_next(210, 301), - on.on_next(220, 102), - on.on_next(220, 202), - on.on_next(220, 302), - on.on_next(230, 203), - on.on_next(230, 303), - on.on_next(240, 204), - on.on_next(240, 304), - on.on_next(310, 103), - on.on_next(320, 104), - on.on_next(320, 305), - on.on_next(410, 105), - on.on_next(420, 106), - on.on_completed(430) + on.next(210, 101), + on.next(210, 201), + on.next(210, 301), + on.next(220, 102), + on.next(220, 202), + on.next(220, 302), + on.next(230, 203), + on.next(230, 303), + on.next(240, 204), + on.next(240, 304), + on.next(310, 103), + on.next(320, 104), + on.next(320, 305), + on.next(410, 105), + on.next(420, 106), + on.completed(430) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 5972ac2..27bc574 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -49,20 +49,20 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(110, 7), - on.on_next(220, 3), - on.on_next(280, 4), - on.on_next(290, 1), - on.on_next(340, 8), - on.on_next(360, 5), - on.on_next(370, 6), - on.on_next(390, 7), - on.on_next(410, 13), - on.on_next(430, 2), - on.on_next(450, 9), - on.on_next(520, 11), - on.on_next(560, 20), - on.on_completed(600) + on.next(110, 7), + on.next(220, 3), + on.next(280, 4), + on.next(290, 1), + on.next(340, 8), + on.next(360, 5), + on.next(370, 6), + on.next(390, 7), + on.next(410, 13), + on.next(430, 2), + on.next(450, 9), + on.next(520, 11), + on.next(560, 20), + on.completed(600) }); auto res = w.make_subscriber(); @@ -130,11 +130,11 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(340, 8), - on.on_next(360, 5), - on.on_next(370, 6), - on.on_next(390, 7), - on.on_next(520, 11) + on.next(340, 8), + on.next(360, 5), + on.next(370, 6), + on.next(390, 7), + on.next(520, 11) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -164,20 +164,20 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ std::runtime_error ex("publish on_error"); auto xs = sc.make_hot_observable({ - on.on_next(110, 7), - on.on_next(220, 3), - on.on_next(280, 4), - on.on_next(290, 1), - on.on_next(340, 8), - on.on_next(360, 5), - on.on_next(370, 6), - on.on_next(390, 7), - on.on_next(410, 13), - on.on_next(430, 2), - on.on_next(450, 9), - on.on_next(520, 11), - on.on_next(560, 20), - on.on_error(600, ex) + on.next(110, 7), + on.next(220, 3), + on.next(280, 4), + on.next(290, 1), + on.next(340, 8), + on.next(360, 5), + on.next(370, 6), + on.next(390, 7), + on.next(410, 13), + on.next(430, 2), + on.next(450, 9), + on.next(520, 11), + on.next(560, 20), + on.error(600, ex) }); auto res = w.make_subscriber(); @@ -231,13 +231,13 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(340, 8), - on.on_next(360, 5), - on.on_next(370, 6), - on.on_next(390, 7), - on.on_next(520, 11), - on.on_next(560, 20), - on.on_error(600, ex) + on.next(340, 8), + on.next(360, 5), + on.next(370, 6), + on.next(390, 7), + on.next(520, 11), + on.next(560, 20), + on.error(600, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -263,20 +263,20 @@ SCENARIO("publish basic with initial value", "[publish][multicast][behavior][ope const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(110, 7), - on.on_next(220, 3), - on.on_next(280, 4), - on.on_next(290, 1), - on.on_next(340, 8), - on.on_next(360, 5), - on.on_next(370, 6), - on.on_next(390, 7), - on.on_next(410, 13), - on.on_next(430, 2), - on.on_next(450, 9), - on.on_next(520, 11), - on.on_next(560, 20), - on.on_completed(600) + on.next(110, 7), + on.next(220, 3), + on.next(280, 4), + on.next(290, 1), + on.next(340, 8), + on.next(360, 5), + on.next(370, 6), + on.next(390, 7), + on.next(410, 13), + on.next(430, 2), + on.next(450, 9), + on.next(520, 11), + on.next(560, 20), + on.completed(600) }); auto res = w.make_subscriber(); @@ -343,12 +343,12 @@ SCENARIO("publish basic with initial value", "[publish][multicast][behavior][ope THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(200, 1979), - on.on_next(340, 8), - on.on_next(360, 5), - on.on_next(370, 6), - on.on_next(390, 7), - on.on_next(520, 11) + on.next(200, 1979), + on.next(340, 8), + on.next(360, 5), + on.next(370, 6), + on.next(390, 7), + on.next(520, 11) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/reduce.cpp b/Rx/v2/test/operators/reduce.cpp index 4872ca5..8a552e3 100644 --- a/Rx/v2/test/operators/reduce.cpp +++ b/Rx/v2/test/operators/reduce.cpp @@ -14,13 +14,13 @@ SCENARIO("reduce some data with seed", "[reduce][operators]"){ int seed = 42; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 0), - on.on_next(220, 1), - on.on_next(230, 2), - on.on_next(240, 3), - on.on_next(250, 4), - on.on_completed(260) + on.next(150, 1), + on.next(210, 0), + on.next(220, 1), + on.next(230, 2), + on.next(240, 3), + on.next(250, 4), + on.completed(260) }); auto sum = xs.sum(); @@ -44,8 +44,8 @@ SCENARIO("reduce some data with seed", "[reduce][operators]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(260, (seed + 0 + 1 + 2 + 3 + 4) * 5), - on.on_completed(260) + on.next(260, (seed + 0 + 1 + 2 + 3 + 4) * 5), + on.completed(260) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -70,11 +70,11 @@ SCENARIO("average some data", "[reduce][average][operators]"){ const rxsc::test::messages d_on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 3), - on.on_next(220, 4), - on.on_next(230, 2), - on.on_completed(250) + on.next(150, 1), + on.next(210, 3), + on.next(220, 4), + on.next(230, 2), + on.completed(250) }); WHEN("mapped to ints that are one larger"){ @@ -87,8 +87,8 @@ SCENARIO("average some data", "[reduce][average][operators]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - d_on.on_next(250, 3.0), - d_on.on_completed(250) + d_on.next(250, 3.0), + d_on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/repeat.cpp b/Rx/v2/test/operators/repeat.cpp index 10361ea..cf91a37 100644 --- a/Rx/v2/test/operators/repeat.cpp +++ b/Rx/v2/test/operators/repeat.cpp @@ -12,10 +12,10 @@ SCENARIO("repeat, basic test", "[repeat][operators]"){ const rxsc::test::messages on; auto xs = sc.make_cold_observable({ - on.on_next(100, 1), - on.on_next(150, 2), - on.on_next(200, 3), - on.on_completed(250) + on.next(100, 1), + on.next(150, 2), + on.next(200, 3), + on.completed(250) }); WHEN("infinite repeat is launched"){ @@ -31,15 +31,15 @@ SCENARIO("repeat, basic test", "[repeat][operators]"){ THEN("the output contains 3 sets of ints"){ auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(350, 2), - on.on_next(400, 3), - on.on_next(550, 1), - on.on_next(600, 2), - on.on_next(650, 3), - on.on_next(800, 1), - on.on_next(850, 2), - on.on_next(900, 3) + on.next(300, 1), + on.next(350, 2), + on.next(400, 3), + on.next(550, 1), + on.next(600, 2), + on.next(650, 3), + on.next(800, 1), + on.next(850, 2), + on.next(900, 3) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -66,9 +66,9 @@ SCENARIO("repeat, infinite observable test", "[repeat][operators]"){ const rxsc::test::messages on; auto xs = sc.make_cold_observable({ - on.on_next(100, 1), - on.on_next(150, 2), - on.on_next(200, 3) + on.next(100, 1), + on.next(150, 2), + on.next(200, 3) }); WHEN("infinite repeat is launched"){ @@ -84,9 +84,9 @@ SCENARIO("repeat, infinite observable test", "[repeat][operators]"){ THEN("the output contains a set of ints"){ auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(350, 2), - on.on_next(400, 3) + on.next(300, 1), + on.next(350, 2), + on.next(400, 3) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -112,10 +112,10 @@ SCENARIO("repeat, error test", "[repeat][operators]"){ std::runtime_error ex("repeat on_error from source"); auto xs = sc.make_cold_observable({ - on.on_next(100, 1), - on.on_next(150, 2), - on.on_next(200, 3), - on.on_error(250, ex) + on.next(100, 1), + on.next(150, 2), + on.next(200, 3), + on.error(250, ex) }); WHEN("infinite repeat is launched"){ @@ -131,10 +131,10 @@ SCENARIO("repeat, error test", "[repeat][operators]"){ THEN("the output contains a set of ints and an error"){ auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(350, 2), - on.on_next(400, 3), - on.on_error(450, ex) + on.next(300, 1), + on.next(350, 2), + on.next(400, 3), + on.error(450, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -158,10 +158,10 @@ SCENARIO("countable repeat, basic test", "[repeat][operators]"){ const rxsc::test::messages on; auto xs = sc.make_cold_observable({ - on.on_next(5, 1), - on.on_next(10, 2), - on.on_next(15, 3), - on.on_completed(20) + on.next(5, 1), + on.next(10, 2), + on.next(15, 3), + on.completed(20) }); WHEN("repeat of 3 iterations is launched"){ @@ -177,16 +177,16 @@ SCENARIO("countable repeat, basic test", "[repeat][operators]"){ THEN("the output contains 3 sets of ints"){ auto required = rxu::to_vector({ - on.on_next(205, 1), - on.on_next(210, 2), - on.on_next(215, 3), - on.on_next(225, 1), - on.on_next(230, 2), - on.on_next(235, 3), - on.on_next(245, 1), - on.on_next(250, 2), - on.on_next(255, 3), - on.on_completed(260) + on.next(205, 1), + on.next(210, 2), + on.next(215, 3), + on.next(225, 1), + on.next(230, 2), + on.next(235, 3), + on.next(245, 1), + on.next(250, 2), + on.next(255, 3), + on.completed(260) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -212,10 +212,10 @@ SCENARIO("countable repeat, dispose test", "[repeat][operators]"){ const rxsc::test::messages on; auto xs = sc.make_cold_observable({ - on.on_next(5, 1), - on.on_next(10, 2), - on.on_next(15, 3), - on.on_completed(20) + on.next(5, 1), + on.next(10, 2), + on.next(15, 3), + on.completed(20) }); WHEN("repeat of 3 iterations is launched"){ @@ -232,11 +232,11 @@ SCENARIO("countable repeat, dispose test", "[repeat][operators]"){ THEN("the output contains less than 2 full sets of ints"){ auto required = rxu::to_vector({ - on.on_next(205, 1), - on.on_next(210, 2), - on.on_next(215, 3), - on.on_next(225, 1), - on.on_next(230, 2), + on.next(205, 1), + on.next(210, 2), + on.next(215, 3), + on.next(225, 1), + on.next(230, 2), }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -261,9 +261,9 @@ SCENARIO("countable repeat, infinite observable test", "[repeat][operators]"){ const rxsc::test::messages on; auto xs = sc.make_cold_observable({ - on.on_next(100, 1), - on.on_next(150, 2), - on.on_next(200, 3) + on.next(100, 1), + on.next(150, 2), + on.next(200, 3) }); WHEN("infinite repeat is launched"){ @@ -279,9 +279,9 @@ SCENARIO("countable repeat, infinite observable test", "[repeat][operators]"){ THEN("the output contains a set of ints"){ auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(350, 2), - on.on_next(400, 3) + on.next(300, 1), + on.next(350, 2), + on.next(400, 3) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -307,10 +307,10 @@ SCENARIO("countable repeat, error test", "[repeat][operators]"){ std::runtime_error ex("repeat on_error from source"); auto xs = sc.make_cold_observable({ - on.on_next(100, 1), - on.on_next(150, 2), - on.on_next(200, 3), - on.on_error(250, ex) + on.next(100, 1), + on.next(150, 2), + on.next(200, 3), + on.error(250, ex) }); WHEN("infinite repeat is launched"){ @@ -326,10 +326,10 @@ SCENARIO("countable repeat, error test", "[repeat][operators]"){ THEN("the output contains a set of ints and an error"){ auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(350, 2), - on.on_next(400, 3), - on.on_error(450, ex) + on.next(300, 1), + on.next(350, 2), + on.next(400, 3), + on.error(450, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/scan.cpp b/Rx/v2/test/operators/scan.cpp index 58ec27e..9d60d11 100644 --- a/Rx/v2/test/operators/scan.cpp +++ b/Rx/v2/test/operators/scan.cpp @@ -14,7 +14,7 @@ SCENARIO("scan: seed, never", "[scan][operators]"){ int seed = 1; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), + on.next(150, 1), }); WHEN("mapped to ints that are one larger"){ @@ -56,8 +56,8 @@ SCENARIO("scan: seed, empty", "[scan][operators]"){ int seed = 1; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(250) + on.next(150, 1), + on.completed(250) }); WHEN("mapped to ints that are one larger"){ @@ -75,7 +75,7 @@ SCENARIO("scan: seed, empty", "[scan][operators]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_completed(250) + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -101,9 +101,9 @@ SCENARIO("scan: seed, return", "[scan][operators]"){ int seed = 1; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(220, 2), - on.on_completed(250) + on.next(150, 1), + on.next(220, 2), + on.completed(250) }); WHEN("mapped to ints that are one larger"){ @@ -121,8 +121,8 @@ SCENARIO("scan: seed, return", "[scan][operators]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(220, seed + 2), - on.on_completed(250) + on.next(220, seed + 2), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -150,8 +150,8 @@ SCENARIO("scan: seed, throw", "[scan][operators]"){ std::runtime_error ex("scan on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(250, ex) + on.next(150, 1), + on.error(250, ex) }); WHEN("mapped to ints that are one larger"){ @@ -169,7 +169,7 @@ SCENARIO("scan: seed, throw", "[scan][operators]"){ THEN("the output stops on error"){ auto required = rxu::to_vector({ - on.on_error(250, ex) + on.error(250, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -195,12 +195,12 @@ SCENARIO("scan: seed, some data", "[scan][operators]"){ int seed = 1; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("mapped to ints that are one larger"){ @@ -218,11 +218,11 @@ SCENARIO("scan: seed, some data", "[scan][operators]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(210, seed + 2), - on.on_next(220, seed + 2 + 3), - on.on_next(230, seed + 2 + 3 + 4), - on.on_next(240, seed + 2 + 3 + 4 + 5), - on.on_completed(250) + on.next(210, seed + 2), + on.next(220, seed + 2 + 3), + on.next(230, seed + 2 + 3 + 4), + on.next(240, seed + 2 + 3 + 4 + 5), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -250,12 +250,12 @@ SCENARIO("scan: seed, accumulator throws", "[scan][operators]"){ std::runtime_error ex("scan on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("mapped to ints that are one larger"){ @@ -276,9 +276,9 @@ SCENARIO("scan: seed, accumulator throws", "[scan][operators]"){ THEN("the output stops on error"){ auto required = rxu::to_vector({ - on.on_next(210, seed + 2), - on.on_next(220, seed + 2 + 3), - on.on_error(230, ex) + on.next(210, seed + 2), + on.next(220, seed + 2 + 3), + on.error(230, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/skip.cpp b/Rx/v2/test/operators/skip.cpp index 72ede48..2596e74 100644 --- a/Rx/v2/test/operators/skip.cpp +++ b/Rx/v2/test/operators/skip.cpp @@ -12,26 +12,26 @@ SCENARIO("skip, complete after", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("more values than generated are skipped"){ @@ -47,7 +47,7 @@ SCENARIO("skip, complete after", "[skip][operators]"){ THEN("the output only contains only complete message"){ auto required = rxu::to_vector({ - on.on_completed(690) + on.completed(690) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -71,26 +71,26 @@ SCENARIO("skip, complete same", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("exact number of values is skipped"){ @@ -106,7 +106,7 @@ SCENARIO("skip, complete same", "[skip][operators]"){ THEN("the output only contains only complete message"){ auto required = rxu::to_vector({ - on.on_completed(690) + on.completed(690) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -130,26 +130,26 @@ SCENARIO("skip, complete before", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("part of values is skipped"){ @@ -165,14 +165,14 @@ SCENARIO("skip, complete before", "[skip][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -196,26 +196,26 @@ SCENARIO("skip, complete zero", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("no values are skipped"){ @@ -231,24 +231,24 @@ SCENARIO("skip, complete zero", "[skip][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -274,26 +274,26 @@ SCENARIO("skip, error after", "[skip][operators]"){ std::runtime_error ex("skip on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, ex) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, ex) }); WHEN("more values than generated are skipped"){ @@ -309,7 +309,7 @@ SCENARIO("skip, error after", "[skip][operators]"){ THEN("the output only contains only error message"){ auto required = rxu::to_vector({ - on.on_error(690, ex) + on.error(690, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -335,26 +335,26 @@ SCENARIO("skip, error same", "[skip][operators]"){ std::runtime_error ex("skip on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, ex) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, ex) }); WHEN("exact number of values is skipped"){ @@ -370,7 +370,7 @@ SCENARIO("skip, error same", "[skip][operators]"){ THEN("the output only contains only error message"){ auto required = rxu::to_vector({ - on.on_error(690, ex) + on.error(690, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -396,26 +396,26 @@ SCENARIO("skip, error before", "[skip][operators]"){ std::runtime_error ex("skip on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, ex) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, ex) }); WHEN("part of values is skipped"){ @@ -431,21 +431,21 @@ SCENARIO("skip, error before", "[skip][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, ex) + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -469,25 +469,25 @@ SCENARIO("skip, dispose before", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10) }); WHEN("all generated values are skipped"){ @@ -526,25 +526,25 @@ SCENARIO("skip, dispose after", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10) }); WHEN("some generated values are skipped"){ @@ -561,11 +561,11 @@ SCENARIO("skip, dispose after", "[skip][operators]"){ THEN("the output contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11) + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -589,17 +589,17 @@ SCENARIO("skip, consecutive", "[skip][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_completed(400) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.completed(400) }); WHEN("3+2 values are skipped"){ @@ -616,10 +616,10 @@ SCENARIO("skip, consecutive", "[skip][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_completed(400) + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.completed(400) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/skip_until.cpp b/Rx/v2/test/operators/skip_until.cpp index 51db1ba..2b44673 100644 --- a/Rx/v2/test/operators/skip_until.cpp +++ b/Rx/v2/test/operators/skip_until.cpp @@ -12,18 +12,18 @@ SCENARIO("skip_until, some data next", "[skip_until][skip][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 99), - on.on_completed(230) + on.next(150, 1), + on.next(225, 99), + on.completed(230) }); WHEN("one is taken until the other emits a marble"){ @@ -39,9 +39,9 @@ SCENARIO("skip_until, some data next", "[skip_until][skip][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -75,17 +75,17 @@ SCENARIO("skip_until, some data error", "[skip_until][skip][operators]"){ std::runtime_error ex("skip_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) + on.next(150, 1), + on.error(225, ex) }); WHEN("one is taken until the other emits a marble"){ @@ -101,7 +101,7 @@ SCENARIO("skip_until, some data error", "[skip_until][skip][operators]"){ THEN("the output only contains error message"){ auto required = rxu::to_vector({ - on.on_error(225, ex) + on.error(225, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -135,15 +135,15 @@ SCENARIO("skip_until, error some data", "[skip_until][skip][operators]"){ std::runtime_error ex("skip_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_error(220, ex) + on.next(150, 1), + on.next(210, 2), + on.error(220, ex) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(230, 3), - on.on_completed(250) + on.next(150, 1), + on.next(230, 3), + on.completed(250) }); WHEN("one is taken until the other emits a marble"){ @@ -159,7 +159,7 @@ SCENARIO("skip_until, error some data", "[skip_until][skip][operators]"){ THEN("the output only contains error message"){ auto required = rxu::to_vector({ - on.on_error(220, ex) + on.error(220, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -191,17 +191,17 @@ SCENARIO("skip_until, some data empty", "[skip_until][skip][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(225) + on.next(150, 1), + on.completed(225) }); WHEN("one is taken until the other emits a marble"){ @@ -247,13 +247,13 @@ SCENARIO("skip_until, never next", "[skip_until][skip][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 2), - on.on_completed(250) + on.next(150, 1), + on.next(225, 2), + on.completed(250) }); WHEN("one is taken until the other emits a marble"){ @@ -301,12 +301,12 @@ SCENARIO("skip_until, never error", "[skip_until][skip][operators]"){ std::runtime_error ex("skip_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) + on.next(150, 1), + on.error(225, ex) }); WHEN("one is taken until the other emits a marble"){ @@ -322,7 +322,7 @@ SCENARIO("skip_until, never error", "[skip_until][skip][operators]"){ THEN("the output only contains error message"){ auto required = rxu::to_vector({ - on.on_error(225, ex) + on.error(225, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -356,17 +356,17 @@ SCENARIO("skip_until, some data error after completed", "[skip_until][skip][oper std::runtime_error ex("skip_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(300, ex) + on.next(150, 1), + on.error(300, ex) }); WHEN("one is taken until the other emits a marble"){ @@ -382,7 +382,7 @@ SCENARIO("skip_until, some data error after completed", "[skip_until][skip][oper THEN("the output only contains error message"){ auto required = rxu::to_vector({ - on.on_error(300, ex) + on.error(300, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -414,16 +414,16 @@ SCENARIO("skip_until, some data never", "[skip_until][skip][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("one is taken until the other emits a marble"){ @@ -469,12 +469,12 @@ SCENARIO("skip_until, never empty", "[skip_until][skip][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(225) + on.next(150, 1), + on.completed(225) }); WHEN("one is taken until the other emits a marble"){ @@ -520,11 +520,11 @@ SCENARIO("skip_until, never never", "[skip_until][skip][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("one is taken until the other emits a marble"){ diff --git a/Rx/v2/test/operators/switch_on_next.cpp b/Rx/v2/test/operators/switch_on_next.cpp index 9a06b68..32c4bac 100644 --- a/Rx/v2/test/operators/switch_on_next.cpp +++ b/Rx/v2/test/operators/switch_on_next.cpp @@ -15,36 +15,36 @@ SCENARIO("switch_on_next - some changes", "[switch_on_next][operators]"){ const rxsc::test::messages> o_on; auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto ys2 = sc.make_cold_observable({ - on.on_next(10, 201), - on.on_next(20, 202), - on.on_next(30, 203), - on.on_next(40, 204), - on.on_completed(50) + on.next(10, 201), + on.next(20, 202), + on.next(30, 203), + on.next(40, 204), + on.completed(50) }); auto ys3 = sc.make_cold_observable({ - on.on_next(10, 301), - on.on_next(20, 302), - on.on_next(30, 303), - on.on_next(40, 304), - on.on_completed(150) + on.next(10, 301), + on.next(20, 302), + on.next(30, 303), + on.next(40, 304), + on.completed(150) }); auto xs = sc.make_hot_observable({ - o_on.on_next(300, ys1), - o_on.on_next(400, ys2), - o_on.on_next(500, ys3), - o_on.on_completed(600) + o_on.next(300, ys1), + o_on.next(400, ys2), + o_on.next(500, ys3), + o_on.completed(600) }); WHEN("distinct values are taken"){ @@ -57,17 +57,17 @@ SCENARIO("switch_on_next - some changes", "[switch_on_next][operators]"){ THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 201), - on.on_next(420, 202), - on.on_next(430, 203), - on.on_next(440, 204), - on.on_next(510, 301), - on.on_next(520, 302), - on.on_next(530, 303), - on.on_next(540, 304), - on.on_completed(650) + on.next(310, 101), + on.next(320, 102), + on.next(410, 201), + on.next(420, 202), + on.next(430, 203), + on.next(440, 204), + on.next(510, 301), + on.next(520, 302), + on.next(530, 303), + on.next(540, 304), + on.completed(650) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -118,36 +118,36 @@ SCENARIO("switch_on_next - inner throws", "[switch_on_next][operators]"){ std::runtime_error ex("switch_on_next on_error from source"); auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto ys2 = sc.make_cold_observable({ - on.on_next(10, 201), - on.on_next(20, 202), - on.on_next(30, 203), - on.on_next(40, 204), - on.on_error(50, ex) + on.next(10, 201), + on.next(20, 202), + on.next(30, 203), + on.next(40, 204), + on.error(50, ex) }); auto ys3 = sc.make_cold_observable({ - on.on_next(10, 301), - on.on_next(20, 302), - on.on_next(30, 303), - on.on_next(40, 304), - on.on_completed(150) + on.next(10, 301), + on.next(20, 302), + on.next(30, 303), + on.next(40, 304), + on.completed(150) }); auto xs = sc.make_hot_observable({ - o_on.on_next(300, ys1), - o_on.on_next(400, ys2), - o_on.on_next(500, ys3), - o_on.on_completed(600) + o_on.next(300, ys1), + o_on.next(400, ys2), + o_on.next(500, ys3), + o_on.completed(600) }); WHEN("distinct values are taken"){ @@ -160,13 +160,13 @@ SCENARIO("switch_on_next - inner throws", "[switch_on_next][operators]"){ THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 201), - on.on_next(420, 202), - on.on_next(430, 203), - on.on_next(440, 204), - on.on_error(450, ex) + on.next(310, 101), + on.next(320, 102), + on.next(410, 201), + on.next(420, 202), + on.next(430, 203), + on.next(440, 204), + on.error(450, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -215,27 +215,27 @@ SCENARIO("switch_on_next - outer throws", "[switch_on_next][operators]"){ std::runtime_error ex("switch_on_next on_error from source"); auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto ys2 = sc.make_cold_observable({ - on.on_next(10, 201), - on.on_next(20, 202), - on.on_next(30, 203), - on.on_next(40, 204), - on.on_completed(50) + on.next(10, 201), + on.next(20, 202), + on.next(30, 203), + on.next(40, 204), + on.completed(50) }); auto xs = sc.make_hot_observable({ - o_on.on_next(300, ys1), - o_on.on_next(400, ys2), - o_on.on_error(500, ex) + o_on.next(300, ys1), + o_on.next(400, ys2), + o_on.error(500, ex) }); WHEN("distinct values are taken"){ @@ -248,13 +248,13 @@ SCENARIO("switch_on_next - outer throws", "[switch_on_next][operators]"){ THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 201), - on.on_next(420, 202), - on.on_next(430, 203), - on.on_next(440, 204), - on.on_error(500, ex) + on.next(310, 101), + on.next(320, 102), + on.next(410, 201), + on.next(420, 202), + on.next(430, 203), + on.next(440, 204), + on.error(500, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -295,7 +295,7 @@ SCENARIO("switch_on_next - no inner", "[switch_on_next][operators]"){ const rxsc::test::messages> o_on; auto xs = sc.make_hot_observable({ - o_on.on_completed(500) + o_on.completed(500) }); WHEN("distinct values are taken"){ @@ -308,7 +308,7 @@ SCENARIO("switch_on_next - no inner", "[switch_on_next][operators]"){ THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_completed(500) + on.completed(500) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -333,18 +333,18 @@ SCENARIO("switch_on_next - inner completes", "[switch_on_next][operators]"){ const rxsc::test::messages> o_on; auto ys1 = sc.make_cold_observable({ - on.on_next(10, 101), - on.on_next(20, 102), - on.on_next(110, 103), - on.on_next(120, 104), - on.on_next(210, 105), - on.on_next(220, 106), - on.on_completed(230) + on.next(10, 101), + on.next(20, 102), + on.next(110, 103), + on.next(120, 104), + on.next(210, 105), + on.next(220, 106), + on.completed(230) }); auto xs = sc.make_hot_observable({ - o_on.on_next(300, ys1), - o_on.on_completed(540) + o_on.next(300, ys1), + o_on.completed(540) }); WHEN("distinct values are taken"){ @@ -357,13 +357,13 @@ SCENARIO("switch_on_next - inner completes", "[switch_on_next][operators]"){ THEN("the output only contains distinct items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(310, 101), - on.on_next(320, 102), - on.on_next(410, 103), - on.on_next(420, 104), - on.on_next(510, 105), - on.on_next(520, 106), - on.on_completed(540) + on.next(310, 101), + on.next(320, 102), + on.next(410, 103), + on.next(420, 104), + on.next(510, 105), + on.next(520, 106), + on.completed(540) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/take.cpp b/Rx/v2/test/operators/take.cpp index 83354ef..846734b 100644 --- a/Rx/v2/test/operators/take.cpp +++ b/Rx/v2/test/operators/take.cpp @@ -13,12 +13,12 @@ SCENARIO("take 2", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); WHEN("2 values are taken"){ @@ -34,9 +34,9 @@ SCENARIO("take 2", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_completed(220) + on.next(210, 2), + on.next(220, 3), + on.completed(220) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -61,26 +61,26 @@ SCENARIO("take, complete after", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("20 values are taken"){ @@ -96,24 +96,24 @@ SCENARIO("take, complete after", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -138,26 +138,26 @@ SCENARIO("take, complete same", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("17 values are taken"){ @@ -173,24 +173,24 @@ SCENARIO("take, complete same", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(630) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(630) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -215,26 +215,26 @@ SCENARIO("take, complete before", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(690) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(690) }); WHEN("10 values are taken"){ @@ -250,17 +250,17 @@ SCENARIO("take, complete before", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_completed(415) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.completed(415) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -287,26 +287,26 @@ SCENARIO("take, error after", "[take][operators]"){ std::runtime_error ex("take on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, ex) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, ex) }); WHEN("20 values are taken"){ @@ -322,24 +322,24 @@ SCENARIO("take, error after", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, ex) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -364,26 +364,26 @@ SCENARIO("take, error same", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, std::runtime_error("error in unsubscribed stream")) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, std::runtime_error("error in unsubscribed stream")) }); WHEN("17 values are taken"){ @@ -399,24 +399,24 @@ SCENARIO("take, error same", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_completed(630) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.completed(630) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -441,26 +441,26 @@ SCENARIO("take, error before", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10), - on.on_error(690, std::runtime_error("error in unsubscribed stream")) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10), + on.error(690, std::runtime_error("error in unsubscribed stream")) }); WHEN("3 values are taken"){ @@ -476,10 +476,10 @@ SCENARIO("take, error before", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_completed(270) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.completed(270) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -504,25 +504,25 @@ SCENARIO("take, dispose before", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10) }); WHEN("3 values are taken"){ @@ -539,8 +539,8 @@ SCENARIO("take, dispose before", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13) + on.next(210, 9), + on.next(230, 13) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -565,25 +565,25 @@ SCENARIO("take, dispose after", "[take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 6), - on.on_next(150, 4), - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_next(280, 1), - on.on_next(300, -1), - on.on_next(310, 3), - on.on_next(340, 8), - on.on_next(370, 11), - on.on_next(410, 15), - on.on_next(415, 16), - on.on_next(460, 72), - on.on_next(510, 76), - on.on_next(560, 32), - on.on_next(570, -100), - on.on_next(580, -3), - on.on_next(590, 5), - on.on_next(630, 10) + on.next(70, 6), + on.next(150, 4), + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.next(280, 1), + on.next(300, -1), + on.next(310, 3), + on.next(340, 8), + on.next(370, 11), + on.next(410, 15), + on.next(415, 16), + on.next(460, 72), + on.next(510, 76), + on.next(560, 32), + on.next(570, -100), + on.next(580, -3), + on.next(590, 5), + on.next(630, 10) }); WHEN("3 values are taken"){ @@ -600,10 +600,10 @@ SCENARIO("take, dispose after", "[take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 9), - on.on_next(230, 13), - on.on_next(270, 7), - on.on_completed(270) + on.next(210, 9), + on.next(230, 13), + on.next(270, 7), + on.completed(270) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/take_until.cpp b/Rx/v2/test/operators/take_until.cpp index 432b7e3..8afb0f6 100644 --- a/Rx/v2/test/operators/take_until.cpp +++ b/Rx/v2/test/operators/take_until.cpp @@ -12,18 +12,18 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto ys = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 99), - on.on_completed(230) + on.next(150, 1), + on.next(225, 99), + on.completed(230) }); WHEN("one is taken until the other emits a marble"){ @@ -39,9 +39,9 @@ SCENARIO("take_until trigger on_next", "[take_until][take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_completed(225) + on.next(210, 2), + on.next(220, 3), + on.completed(225) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -74,18 +74,18 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 99), - on.on_completed(230) + on.next(150, 1), + on.next(225, 99), + on.completed(230) }); WHEN("one is taken until the other emits a marble"){ @@ -101,9 +101,9 @@ SCENARIO("take_until, preempt some data next", "[take_until][take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_completed(225) + on.next(210, 2), + on.next(220, 3), + on.completed(225) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -138,17 +138,17 @@ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]") std::runtime_error ex("take_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) + on.next(150, 1), + on.error(225, ex) }); WHEN("one is taken until the other emits a marble"){ @@ -164,9 +164,9 @@ SCENARIO("take_until, preempt some data error", "[take_until][take][operators]") THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_error(225, ex) + on.next(210, 2), + on.next(220, 3), + on.error(225, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -199,17 +199,17 @@ SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(225) + on.next(150, 1), + on.completed(225) }); WHEN("one is taken until the other emits a marble"){ @@ -225,11 +225,11 @@ SCENARIO("take_until, no-preempt some data empty", "[take_until][take][operators THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -262,16 +262,16 @@ SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(150, 1), + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("one is taken until the other emits a marble"){ @@ -287,11 +287,11 @@ SCENARIO("take_until, no-preempt some data never", "[take_until][take][operators THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(220, 3), - on.on_next(230, 4), - on.on_next(240, 5), - on.on_completed(250) + on.next(210, 2), + on.next(220, 3), + on.next(230, 4), + on.next(240, 5), + on.completed(250) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -324,13 +324,13 @@ SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(225, 2), //! - on.on_completed(250) + on.next(150, 1), + on.next(225, 2), //! + on.completed(250) }); WHEN("one is taken until the other emits a marble"){ @@ -346,7 +346,7 @@ SCENARIO("take_until, preempt never next", "[take_until][take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_completed(225) + on.completed(225) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -381,12 +381,12 @@ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ std::runtime_error ex("take_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) + on.next(150, 1), + on.error(225, ex) }); WHEN("one is taken until the other emits a marble"){ @@ -402,7 +402,7 @@ SCENARIO("take_until, preempt never error", "[take_until][take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_error(225, ex) + on.error(225, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -435,12 +435,12 @@ SCENARIO("take_until, no-preempt never empty", "[take_until][take][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_completed(225) + on.next(150, 1), + on.completed(225) }); WHEN("one is taken until the other emits a marble"){ @@ -487,11 +487,11 @@ SCENARIO("take_until, no-preempt never never", "[take_until][take][operators]"){ const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1) + on.next(150, 1) }); WHEN("one is taken until the other emits a marble"){ @@ -538,15 +538,15 @@ SCENARIO("take_until, preempt before first produced", "[take_until][take][operat const rxsc::test::messages on; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(230, 2), - on.on_completed(240) + on.next(150, 1), + on.next(230, 2), + on.completed(240) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), //! - on.on_completed(220) + on.next(150, 1), + on.next(210, 2), //! + on.completed(220) }); WHEN("one is taken until the other emits a marble"){ @@ -562,7 +562,7 @@ SCENARIO("take_until, preempt before first produced", "[take_until][take][operat THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_completed(210) + on.completed(210) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -597,15 +597,15 @@ SCENARIO("take_until, preempt before first produced, remain silent and proper un bool sourceNotDisposed = false; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(215, std::runtime_error("error in unsubscribed stream")), // should not come - on.on_completed(240) + on.next(150, 1), + on.error(215, std::runtime_error("error in unsubscribed stream")), // should not come + on.completed(240) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(210, 2), //! - on.on_completed(220) + on.next(150, 1), + on.next(210, 2), //! + on.completed(220) }); WHEN("one is taken until the other emits a marble"){ @@ -622,7 +622,7 @@ SCENARIO("take_until, preempt before first produced, remain silent and proper un THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_completed(210) + on.completed(210) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -647,15 +647,15 @@ SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal" bool signalNotDisposed = false; auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(230, 2), - on.on_completed(240) + on.next(150, 1), + on.next(230, 2), + on.completed(240) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(250, 2), - on.on_completed(260) + on.next(150, 1), + on.next(250, 2), + on.completed(260) }); WHEN("one is taken until the other emits a marble"){ @@ -672,8 +672,8 @@ SCENARIO("take_until, no-preempt after last produced, proper unsubscribe signal" THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_next(230, 2), - on.on_completed(240) + on.next(230, 2), + on.completed(240) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -698,13 +698,13 @@ SCENARIO("take_until, error some", "[take_until][take][operators]"){ std::runtime_error ex("take_until on_error from source"); auto l = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_error(225, ex) + on.next(150, 1), + on.error(225, ex) }); auto r = sc.make_hot_observable({ - on.on_next(150, 1), - on.on_next(240, 2) + on.next(150, 1), + on.next(240, 2) }); WHEN("one is taken until the other emits a marble"){ @@ -720,7 +720,7 @@ SCENARIO("take_until, error some", "[take_until][take][operators]"){ THEN("the output only contains items sent while subscribed"){ auto required = rxu::to_vector({ - on.on_error(225, ex) + on.error(225, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index af54699..73ef113 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -17,16 +17,16 @@ SCENARIO("window count, basic", "[window][operators]"){ const rxsc::test::messages> o_on; auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); WHEN("group each int with the next 2 ints"){ @@ -42,18 +42,18 @@ SCENARIO("window count, basic", "[window][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -78,16 +78,16 @@ SCENARIO("window count, inner timings", "[window][operators]"){ const rxsc::test::messages> o_on; auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); WHEN("group each int with the next 2 ints"){ @@ -126,10 +126,10 @@ SCENARIO("window count, inner timings", "[window][operators]"){ THEN("the 1st output window contains ints"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_completed(280) + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.completed(280) }); auto actual = observers[0].messages(); REQUIRE(required == actual); @@ -137,10 +137,10 @@ SCENARIO("window count, inner timings", "[window][operators]"){ THEN("the 2nd output window contains ints"){ auto required = rxu::to_vector({ - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_completed(350) + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.completed(350) }); auto actual = observers[1].messages(); REQUIRE(required == actual); @@ -148,10 +148,10 @@ SCENARIO("window count, inner timings", "[window][operators]"){ THEN("the 3rd output window contains ints"){ auto required = rxu::to_vector({ - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_completed(420) + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.completed(420) }); auto actual = observers[2].messages(); REQUIRE(required == actual); @@ -159,9 +159,9 @@ SCENARIO("window count, inner timings", "[window][operators]"){ THEN("the 4th output window contains ints"){ auto required = rxu::to_vector({ - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); auto actual = observers[3].messages(); REQUIRE(required == actual); @@ -169,7 +169,7 @@ SCENARIO("window count, inner timings", "[window][operators]"){ THEN("the 5th output window only contains complete message"){ auto required = rxu::to_vector({ - on.on_completed(600) + on.completed(600) }); auto actual = observers[4].messages(); REQUIRE(required == actual); @@ -194,16 +194,16 @@ SCENARIO("window count, dispose", "[window][operators]"){ const rxsc::test::messages> o_on; auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_completed(600) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) }); WHEN("group each int with the next 2 ints"){ @@ -220,13 +220,13 @@ SCENARIO("window count, dispose", "[window][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(350, 6) + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(350, 6) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -253,16 +253,16 @@ SCENARIO("window count, error", "[window][operators]"){ std::runtime_error ex("window on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(100, 1), - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_error(600, ex) + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) }); WHEN("group each int with the next 2 ints"){ @@ -278,18 +278,18 @@ SCENARIO("window count, error", "[window][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.on_next(210, 2), - on.on_next(240, 3), - on.on_next(280, 4), - on.on_next(280, 4), - on.on_next(320, 5), - on.on_next(350, 6), - on.on_next(350, 6), - on.on_next(380, 7), - on.on_next(420, 8), - on.on_next(420, 8), - on.on_next(470, 9), - on.on_error(600, ex) + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/sources/create.cpp b/Rx/v2/test/sources/create.cpp index 063ff7e..44dcc30 100644 --- a/Rx/v2/test/sources/create.cpp +++ b/Rx/v2/test/sources/create.cpp @@ -31,8 +31,8 @@ SCENARIO("create stops on completion", "[create][sources]"){ THEN("the output contains all items"){ auto required = rxu::to_vector({ - on.on_next(200, 1), - on.on_next(200, 2) + on.next(200, 1), + on.next(200, 2) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/sources/defer.cpp b/Rx/v2/test/sources/defer.cpp index e9e62c2..79f8c91 100644 --- a/Rx/v2/test/sources/defer.cpp +++ b/Rx/v2/test/sources/defer.cpp @@ -30,8 +30,8 @@ SCENARIO("defer stops on completion", "[defer][sources]"){ [&](){ invoked++; xs.reset(sc.make_cold_observable({ - on.on_next(100, sc.clock()), - on.on_completed(200) + on.next(100, sc.clock()), + on.completed(200) })); return xs.get(); }) @@ -42,8 +42,8 @@ SCENARIO("defer stops on completion", "[defer][sources]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(300, 200L), - on.on_completed(400) + on.next(300, 200L), + on.completed(400) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/sources/scope.cpp b/Rx/v2/test/sources/scope.cpp index b8d36cb..cca805d 100644 --- a/Rx/v2/test/sources/scope.cpp +++ b/Rx/v2/test/sources/scope.cpp @@ -30,10 +30,10 @@ SCENARIO("scope, cold observable", "[scope][sources]"){ int time = 10; auto values = r.get(); std::for_each(values.begin(), values.end(), [&](int &v){ - msg.push_back(on.on_next(time, v)); + msg.push_back(on.next(time, v)); time += 10; }); - msg.push_back(on.on_completed(time)); + msg.push_back(on.completed(time)); xs.reset(sc.make_cold_observable(msg)); return xs.get(); } @@ -45,12 +45,12 @@ SCENARIO("scope, cold observable", "[scope][sources]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(210, 1), - on.on_next(220, 2), - on.on_next(230, 3), - on.on_next(240, 4), - on.on_next(250, 5), - on.on_completed(260) + on.next(210, 1), + on.next(220, 2), + on.next(230, 3), + on.next(240, 4), + on.next(250, 5), + on.completed(260) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -91,10 +91,10 @@ SCENARIO("scope, hot observable", "[scope][sources]"){ int time = 210; auto values = r.get(); std::for_each(values.begin(), values.end(), [&](int &v){ - msg.push_back(on.on_next(time, v)); + msg.push_back(on.next(time, v)); time += 10; }); - msg.push_back(on.on_completed(time)); + msg.push_back(on.completed(time)); xs.reset(sc.make_hot_observable(msg)); return xs.get(); } @@ -106,12 +106,12 @@ SCENARIO("scope, hot observable", "[scope][sources]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(210, 1), - on.on_next(220, 2), - on.on_next(230, 3), - on.on_next(240, 4), - on.on_next(250, 5), - on.on_completed(260) + on.next(210, 1), + on.next(220, 2), + on.next(230, 3), + on.next(240, 4), + on.next(250, 5), + on.completed(260) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -154,8 +154,8 @@ SCENARIO("scope, complete", "[scope][sources]"){ [&](resource r){ ++observable_factory_invoked; xs.reset(sc.make_cold_observable(rxu::to_vector({ - on.on_next(100, r.get()), - on.on_completed(200) + on.next(100, r.get()), + on.completed(200) }))); return xs.get(); } @@ -175,8 +175,8 @@ SCENARIO("scope, complete", "[scope][sources]"){ THEN("the output stops on completion"){ auto required = rxu::to_vector({ - on.on_next(300, 200), - on.on_completed(400) + on.next(300, 200), + on.completed(400) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -221,8 +221,8 @@ SCENARIO("scope, error", "[scope][sources]"){ [&](resource r){ ++observable_factory_invoked; xs.reset(sc.make_cold_observable(rxu::to_vector({ - on.on_next(100, r.get()), - on.on_error(200, ex) + on.next(100, r.get()), + on.error(200, ex) }))); return xs.get(); } @@ -242,8 +242,8 @@ SCENARIO("scope, error", "[scope][sources]"){ THEN("the output stops on error"){ auto required = rxu::to_vector({ - on.on_next(300, 200), - on.on_error(400, ex) + on.next(300, 200), + on.error(400, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -286,8 +286,8 @@ SCENARIO("scope, dispose", "[scope][sources]"){ [&](resource r){ ++observable_factory_invoked; xs.reset(sc.make_cold_observable(rxu::to_vector({ - on.on_next(100, r.get()), - on.on_next(1000, r.get() + 1) + on.next(100, r.get()), + on.next(1000, r.get() + 1) }))); return xs.get(); } @@ -307,7 +307,7 @@ SCENARIO("scope, dispose", "[scope][sources]"){ THEN("the output contains resulting ints"){ auto required = rxu::to_vector({ - on.on_next(300, 200) + on.next(300, 200) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -368,7 +368,7 @@ SCENARIO("scope, throw resource selector", "[scope][sources]"){ THEN("the output stops on error"){ auto required = rxu::to_vector({ - on.on_error(200, ex) + on.error(200, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -421,7 +421,7 @@ SCENARIO("scope, throw resource usage", "[scope][sources]"){ THEN("the output stops on error"){ auto required = rxu::to_vector({ - on.on_error(200, ex) + on.error(200, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index ea2230a..dd097d8 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -441,18 +441,18 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 1), - on.on_next(110, 2), - on.on_next(220, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(410, 6), - on.on_next(520, 7), - on.on_next(630, 8), - on.on_next(710, 9), - on.on_next(870, 10), - on.on_next(940, 11), - on.on_next(1020, 12) + on.next(70, 1), + on.next(110, 2), + on.next(220, 3), + on.next(270, 4), + on.next(340, 5), + on.next(410, 6), + on.next(520, 7), + on.next(630, 8), + on.next(710, 9), + on.next(870, 10), + on.next(940, 11), + on.next(1020, 12) }); rxsub::subject s; @@ -494,9 +494,9 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ THEN("result1 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(340, 5), - on.on_next(410, 6), - on.on_next(520, 7) + on.next(340, 5), + on.next(410, 6), + on.next(520, 7) }); auto actual = results1.get_observer().messages(); REQUIRE(required == actual); @@ -504,9 +504,9 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ THEN("result2 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(410, 6), - on.on_next(520, 7), - on.on_next(630, 8) + on.next(410, 6), + on.next(520, 7), + on.next(630, 8) }); auto actual = results2.get_observer().messages(); REQUIRE(required == actual); @@ -514,7 +514,7 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ THEN("result3 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(940, 11) + on.next(940, 11) }); auto actual = results3.get_observer().messages(); REQUIRE(required == actual); @@ -532,17 +532,17 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ const rxsc::test::messages on; auto xs = sc.make_hot_observable({ - on.on_next(70, 1), - on.on_next(110, 2), - on.on_next(220, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(410, 6), - on.on_next(520, 7), - on.on_completed(630), - on.on_next(640, 9), - on.on_completed(650), - on.on_error(660, std::runtime_error("error on unsubscribed stream")) + on.next(70, 1), + on.next(110, 2), + on.next(220, 3), + on.next(270, 4), + on.next(340, 5), + on.next(410, 6), + on.next(520, 7), + on.completed(630), + on.next(640, 9), + on.completed(650), + on.error(660, std::runtime_error("error on unsubscribed stream")) }); rxsub::subject s; @@ -584,9 +584,9 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ THEN("result1 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(340, 5), - on.on_next(410, 6), - on.on_next(520, 7) + on.next(340, 5), + on.next(410, 6), + on.next(520, 7) }); auto actual = results1.get_observer().messages(); REQUIRE(required == actual); @@ -594,9 +594,9 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ THEN("result2 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(410, 6), - on.on_next(520, 7), - on.on_completed(630) + on.next(410, 6), + on.next(520, 7), + on.completed(630) }); auto actual = results2.get_observer().messages(); REQUIRE(required == actual); @@ -604,7 +604,7 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ THEN("result3 contains expected messages"){ auto required = rxu::to_vector({ - on.on_completed(900) + on.completed(900) }); auto actual = results3.get_observer().messages(); REQUIRE(required == actual); @@ -625,17 +625,17 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ std::runtime_error ex("subject on_error in stream"); auto xs = sc.make_hot_observable({ - on.on_next(70, 1), - on.on_next(110, 2), - on.on_next(220, 3), - on.on_next(270, 4), - on.on_next(340, 5), - on.on_next(410, 6), - on.on_next(520, 7), - on.on_error(630, ex), - on.on_next(640, 9), - on.on_completed(650), - on.on_error(660, std::runtime_error("error on unsubscribed stream")) + on.next(70, 1), + on.next(110, 2), + on.next(220, 3), + on.next(270, 4), + on.next(340, 5), + on.next(410, 6), + on.next(520, 7), + on.error(630, ex), + on.next(640, 9), + on.completed(650), + on.error(660, std::runtime_error("error on unsubscribed stream")) }); rxsub::subject s; @@ -677,9 +677,9 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ THEN("result1 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(340, 5), - on.on_next(410, 6), - on.on_next(520, 7) + on.next(340, 5), + on.next(410, 6), + on.next(520, 7) }); auto actual = results1.get_observer().messages(); REQUIRE(required == actual); @@ -687,9 +687,9 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ THEN("result2 contains expected messages"){ auto required = rxu::to_vector({ - on.on_next(410, 6), - on.on_next(520, 7), - on.on_error(630, ex) + on.next(410, 6), + on.next(520, 7), + on.error(630, ex) }); auto actual = results2.get_observer().messages(); REQUIRE(required == actual); @@ -697,7 +697,7 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ THEN("result3 contains expected messages"){ auto required = rxu::to_vector({ - on.on_error(900, ex) + on.error(900, ex) }); auto actual = results3.get_observer().messages(); REQUIRE(required == actual); diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 0e71bc4..ae8dd39 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -69,7 +69,7 @@ TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) # define the sources of the self test set(ONE_SOURCES ${TEST_DIR}/test.cpp - ${TEST_DIR}/operators/subscribe_on.cpp +# ${TEST_DIR}/operators/subscribe_on.cpp ) add_executable(one_test ${ONE_SOURCES}) TARGET_LINK_LIBRARIES(one_test ${CMAKE_THREAD_LIBS_INIT}) @@ -83,13 +83,21 @@ set(PYTHAGORIAN_SOURCES add_executable(pythagorian ${PYTHAGORIAN_SOURCES}) TARGET_LINK_LIBRARIES(pythagorian ${CMAKE_THREAD_LIBS_INIT}) -# define the sources of the pythagorian example +# define the sources of the println example set(PRINTLN_SOURCES ${EXAMPLES_DIR}/println/main.cpp ) add_executable(println ${PRINTLN_SOURCES}) TARGET_LINK_LIBRARIES(println ${CMAKE_THREAD_LIBS_INIT}) +# define the sources of the tests example +set(TESTS_EXAMPLE_SOURCES + ${EXAMPLES_DIR}/tests/main.cpp + ${EXAMPLES_DIR}/tests/take.cpp +) +add_executable(tests_example ${TESTS_EXAMPLE_SOURCES}) +TARGET_LINK_LIBRARIES(tests_example ${CMAKE_THREAD_LIBS_INIT}) + # configure unit tests via CTest enable_testing() -- GitLab From 30a87eb8980b16b8212832866a1ec3d447cefc4c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 28 Aug 2014 00:17:19 -0700 Subject: [PATCH 423/782] update new retry tests --- Rx/v2/test/operators/retry.cpp | 114 ++++++++++++++++----------------- 1 file changed, 57 insertions(+), 57 deletions(-) diff --git a/Rx/v2/test/operators/retry.cpp b/Rx/v2/test/operators/retry.cpp index 9bec879..f2d4df4 100644 --- a/Rx/v2/test/operators/retry.cpp +++ b/Rx/v2/test/operators/retry.cpp @@ -13,23 +13,23 @@ SCENARIO("retry, basic test", "[retry][operators]") { std::runtime_error ex("retry on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(300, 1), - on.on_next(325, 2), - on.on_next(350, 3), - on.on_error(400, ex), - on.on_next(425, 1), - on.on_next(450, 2), - on.on_next(475, 3), - on.on_next(500, 4), - on.on_error(525, ex), - on.on_next(550, 1), - on.on_next(575, 2), - on.on_next(600, 3), - on.on_next(625, 4), - on.on_next(650, 5), - on.on_next(675, 6), - on.on_next(700, 7), - on.on_completed(725) + on.next(300, 1), + on.next(325, 2), + on.next(350, 3), + on.error(400, ex), + on.next(425, 1), + on.next(450, 2), + on.next(475, 3), + on.next(500, 4), + on.error(525, ex), + on.next(550, 1), + on.next(575, 2), + on.next(600, 3), + on.next(625, 4), + on.next(650, 5), + on.next(675, 6), + on.next(700, 7), + on.completed(725) }); WHEN("infinite retry is launched") { @@ -45,21 +45,21 @@ SCENARIO("retry, basic test", "[retry][operators]") { THEN("the output contains all the data until complete") { auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(325, 2), - on.on_next(350, 3), - on.on_next(425, 1), - on.on_next(450, 2), - on.on_next(475, 3), - on.on_next(500, 4), - on.on_next(550, 1), - on.on_next(575, 2), - on.on_next(600, 3), - on.on_next(625, 4), - on.on_next(650, 5), - on.on_next(675, 6), - on.on_next(700, 7), - on.on_completed(725) + on.next(300, 1), + on.next(325, 2), + on.next(350, 3), + on.next(425, 1), + on.next(450, 2), + on.next(475, 3), + on.next(500, 4), + on.next(550, 1), + on.next(575, 2), + on.next(600, 3), + on.next(625, 4), + on.next(650, 5), + on.next(675, 6), + on.next(700, 7), + on.completed(725) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -87,23 +87,23 @@ SCENARIO("retry with failure", "[retry][operators]") { std::runtime_error ex("retry on_error from source"); auto xs = sc.make_hot_observable({ - on.on_next(300, 1), - on.on_next(325, 2), - on.on_next(350, 3), - on.on_error(400, ex), - on.on_next(425, 1), - on.on_next(450, 2), - on.on_next(475, 3), - on.on_next(500, 4), - on.on_error(525, ex), - on.on_next(550, 1), - on.on_next(575, 2), - on.on_next(600, 3), - on.on_next(625, 4), - on.on_next(650, 5), - on.on_next(675, 6), - on.on_next(700, 7), - on.on_completed(725) + on.next(300, 1), + on.next(325, 2), + on.next(350, 3), + on.error(400, ex), + on.next(425, 1), + on.next(450, 2), + on.next(475, 3), + on.next(500, 4), + on.error(525, ex), + on.next(550, 1), + on.next(575, 2), + on.next(600, 3), + on.next(625, 4), + on.next(650, 5), + on.next(675, 6), + on.next(700, 7), + on.completed(725) }); WHEN("retry of 1 is launched with expected error before complete") { @@ -118,14 +118,14 @@ SCENARIO("retry with failure", "[retry][operators]") { THEN("The output contains all the data until retry fails") { auto required = rxu::to_vector({ - on.on_next(300, 1), - on.on_next(325, 2), - on.on_next(350, 3), - on.on_next(425, 1), - on.on_next(450, 2), - on.on_next(475, 3), - on.on_next(500, 4), - on.on_error(525, ex), + on.next(300, 1), + on.next(325, 2), + on.next(350, 3), + on.next(425, 1), + on.next(450, 2), + on.next(475, 3), + on.next(500, 4), + on.error(525, ex), }); auto actual = res.get_observer().messages(); REQUIRE(actual == required); -- GitLab From ff573fcd26752d14b5e00b7a4e42f147ae7bc92e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 1 Sep 2014 22:38:02 -0700 Subject: [PATCH 424/782] allow conversions to dynamic --- Rx/v2/src/rxcpp/operators/rx-group_by.hpp | 4 +- Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 43 ++++-------------- Rx/v2/src/rxcpp/rx-grouped_observable.hpp | 44 ++++--------------- Rx/v2/src/rxcpp/rx-subscriber.hpp | 15 +++++++ 4 files changed, 33 insertions(+), 73 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp index dcba7ed..5ef609b 100644 --- a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp @@ -59,6 +59,7 @@ struct group_by typedef group_by_traits traits_type; typedef typename traits_type::key_selector_type key_selector_type; typedef typename traits_type::marble_selector_type marble_selector_type; + typedef typename traits_type::marble_type marble_type; typedef typename traits_type::predicate_type predicate_type; typedef typename traits_type::subject_type subject_type; typedef typename traits_type::key_type key_type; @@ -83,7 +84,7 @@ struct group_by { } - struct group_by_observable + struct group_by_observable : public rxs::source_base { subject_type subject; key_type key; @@ -109,7 +110,6 @@ struct group_by { typedef group_by_observer this_type; typedef typename traits_type::grouped_observable_type value_type; - typedef typename traits_type::marble_type marble_type; typedef typename std::decay::type dest_type; typedef observer observer_type; dest_type dest; diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index 0352605..731d844 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -28,15 +28,13 @@ struct has_on_connect template class dynamic_connectable_observable - : public rxs::source_base + : public dynamic_observable { struct state_type : public std::enable_shared_from_this { - typedef std::function)> onsubscribe_type; typedef std::function onconnect_type; - onsubscribe_type on_subscribe; onconnect_type on_connect; }; std::shared_ptr state; @@ -54,9 +52,6 @@ class dynamic_connectable_observable template void construct(SO&& source, rxs::tag_source&&) { auto so = std::make_shared::type>(std::forward(source)); - state->on_subscribe = [so](subscriber o) mutable { - so->on_subscribe(std::move(o)); - }; state->on_connect = [so](composite_subscription cs) mutable { so->on_connect(std::move(cs)); }; @@ -71,45 +66,23 @@ public: } template - explicit dynamic_connectable_observable(SOF&& sof) - : state(std::make_shared()) + explicit dynamic_connectable_observable(SOF sof) + : dynamic_observable(sof) + , state(std::make_shared()) { - construct(std::forward(sof), + construct(std::move(sof), typename std::conditional::value, tag_dynamic_observable, rxs::tag_source>::type()); } template dynamic_connectable_observable(SF&& sf, CF&& cf) - : state(std::make_shared()) + : dynamic_observable(std::forward(sf)) + , state(std::make_shared()) { - state->on_subscribe = std::forward(sf); state->on_connect = std::forward(cf); } - void on_subscribe(subscriber o) const { - state->on_subscribe(std::move(o)); - } - - template - typename std::enable_if::type, observer>::value, void>::type - on_subscribe(Subscriber&& o) const { - auto so = std::make_shared::type>(std::forward(o)); - state->on_subscribe(make_subscriber( - *so, - make_observer_dynamic( - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - }))); - } + using dynamic_observable::on_subscribe; void on_connect(composite_subscription cs) const { state->on_connect(std::move(cs)); diff --git a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp index 3b248af..84deef9 100644 --- a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp @@ -28,7 +28,7 @@ struct has_on_get_key_for template class dynamic_grouped_observable - : public rxs::source_base + : public dynamic_observable { public: typedef typename std::decay::type key_type; @@ -38,10 +38,8 @@ private: struct state_type : public std::enable_shared_from_this { - typedef std::function)> onsubscribe_type; typedef std::function ongetkey_type; - onsubscribe_type on_subscribe; ongetkey_type on_get_key; }; std::shared_ptr state; @@ -62,9 +60,6 @@ private: template void construct(SO&& source, const rxs::tag_source&) { auto so = std::make_shared::type>(std::forward(source)); - state->on_subscribe = [so](subscriber o) mutable { - so->on_subscribe(std::move(o)); - }; state->on_get_key = [so]() mutable { return so->on_get_key(); }; @@ -77,46 +72,23 @@ public: } template - explicit dynamic_grouped_observable(SOF&& sof) - : state(std::make_shared()) + explicit dynamic_grouped_observable(SOF sof) + : dynamic_observable(sof) + , state(std::make_shared()) { - construct(std::forward(sof), + construct(std::move(sof), typename std::conditional::value, tag_dynamic_grouped_observable, rxs::tag_source>::type()); } template dynamic_grouped_observable(SF&& sf, CF&& cf) - : state(std::make_shared()) + : dynamic_observable(std::forward(sf)) + , state(std::make_shared()) { - state->on_subscribe = std::forward(sf); state->on_connect = std::forward(cf); } - void on_subscribe(subscriber o) const { - state->on_subscribe(std::move(o)); - } - - template - typename std::enable_if::type, observer>::value, void>::type - on_subscribe(Subscriber&& o) const { - auto so = std::make_shared::type>(std::forward(o)); - state->on_subscribe( - make_subscriber( - *so, - // on_next - [so](T t){ - so->on_next(t); - }, - // on_error - [so](std::exception_ptr e){ - so->on_error(e); - }, - // on_completed - [so](){ - so->on_completed(); - }). - as_dynamic()); - } + using dynamic_observable::on_subscribe; key_type on_get_key() const { return state->on_get_key(); diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index dbb3615..39e6bdc 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -104,6 +104,21 @@ public: { } + template + friend class subscriber; + + template + subscriber( + const subscriber& o, + typename std::enable_if< + !std::is_same>::value && + std::is_same>::value, void**>::type select = nullptr) + : lifetime(o.lifetime) + , destination(o.destination.as_dynamic()) + , id(o.id) + { + } + template subscriber(trace_id id, composite_subscription cs, U&& o) : lifetime(std::move(cs)) -- GitLab From 2d5d75266d4ecc78e2112fbad96b93c7ad64ec0b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 2 Sep 2014 08:57:27 -0700 Subject: [PATCH 425/782] add more badges using @sheilds_io --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ffa1b1e..9790fff 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,6 @@ -[![Build Status](https://travis-ci.org/Reactive-Extensions/RxCpp.png)](https://travis-ci.org/Reactive-Extensions/RxCpp) +[![Build Status](http://img.shields.io/travis/Reactive-Extensions/RxCpp.svg?style=flat-square)](https://travis-ci.org/Reactive-Extensions/RxCpp) +[![NuGet version](http://img.shields.io/nuget/v/RxCpp.svg?style=flat-square)](http://www.nuget.org/packages/RxCpp/) +[![NuGet downloads](http://img.shields.io/nuget/dt/RxCpp.svg?style=flat-square)](http://www.nuget.org/packages/RxCpp/) # Reactive Extensions: -- GitLab From 539438ba64e7612aef42c96f50d37fe1b2be8a7b Mon Sep 17 00:00:00 2001 From: "Kirk Shoop (MS OPEN TECH)" Date: Wed, 3 Sep 2014 12:45:58 -0700 Subject: [PATCH 426/782] add appveyor CI for windows --- README.md | 5 ++++- appveyor.yml | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 appveyor.yml diff --git a/README.md b/README.md index 9790fff..ed8a4f3 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,7 @@ -[![Build Status](http://img.shields.io/travis/Reactive-Extensions/RxCpp.svg?style=flat-square)](https://travis-ci.org/Reactive-Extensions/RxCpp) +Windows: [![Windows Status](http://img.shields.io/appveyor/ci/kirkshoop/RxCpp-446.svg?style=flat-square)](https://ci.appveyor.com/project/kirkshoop/rxcpp-446) + +Linux & OSX: [![Linux & Osx Status](http://img.shields.io/travis/Reactive-Extensions/RxCpp.svg?style=flat-square)](https://travis-ci.org/Reactive-Extensions/RxCpp) + [![NuGet version](http://img.shields.io/nuget/v/RxCpp.svg?style=flat-square)](http://www.nuget.org/packages/RxCpp/) [![NuGet downloads](http://img.shields.io/nuget/dt/RxCpp.svg?style=flat-square)](http://www.nuget.org/packages/RxCpp/) diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000..98a2cc6 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,19 @@ +version: 2.1.{build} + +branches: +# whitelist + only: + - master + - appveyor + +install: + - git submodule -q update --init + +before_build: + - mkdir projects\build + - cd projects\build + - cmake -G"Visual Studio 12" -T"v120" -B. ..\CMake\ + - cd ..\.. + +build: + project: projects\build\rxcpp.sln -- GitLab From f13776b4c79972f14694ef67a1df6967845131af Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 2 Sep 2014 07:32:07 -0700 Subject: [PATCH 427/782] turn lack of equality support into runtime error --- Rx/v2/src/rxcpp/rx-notification.hpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index b572c27..fb23c36 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -93,6 +93,17 @@ inline std::ostream& operator<< (std::ostream& os, const std::vector& v) { return os; } +template +auto equals(const T& lhs, const T& rhs, int) + -> decltype(lhs == rhs, true) { + return lhs == rhs; +} + +template +bool equals(const T& lhs, const T& rhs, ...) { + throw std::runtime_error("value does not support equality tests"); + return false; +} } @@ -116,7 +127,7 @@ private: virtual bool equals(const typename base::type& other) const { bool result = false; other->accept(make_subscriber(make_observer_dynamic([this, &result](T v) { - result = this->value == v; + result = detail::equals(this->value, v, 0); }))); return result; } -- GitLab From 9deb8a8b25454a37ea9a1c0059d2d5e6749ea524 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 16 Sep 2014 19:15:49 +0400 Subject: [PATCH 428/782] Add buffer_with_time operator including tests. --- Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp | 160 ++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 42 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/buffer.cpp | 504 +++++++++++++++++++ 4 files changed, 707 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp new file mode 100644 index 0000000..f6766d7 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -0,0 +1,160 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_BUFFER_WITH_TIME_HPP) +#define RXCPP_OPERATORS_RX_BUFFER_WITH_TIME_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct buffer_with_time +{ + typedef typename std::decay::type source_value_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + typedef typename std::decay::type duration_type; + + struct buffer_with_time_values + { + buffer_with_time_values(duration_type p, duration_type s, coordination_type c) + : period(p) + , skip(s) + , coordination(c) + { + } + duration_type period; + duration_type skip; + coordination_type coordination; + }; + buffer_with_time_values initial; + + buffer_with_time(duration_type period, duration_type skip, coordination_type coordination) + : initial(period, skip, coordination) + { + } + + template + struct buffer_with_time_observer + { + typedef buffer_with_time_observer this_type; + typedef std::vector value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + + struct buffer_with_time_subscriber_values : public buffer_with_time_values + { + buffer_with_time_subscriber_values(dest_type d, buffer_with_time_values v, coordinator_type c) + : buffer_with_time_values(v) + , dest(std::move(d)) + , coordinator(std::move(c)) + , worker(std::move(coordinator.get_worker())) + { + } + dest_type dest; + coordinator_type coordinator; + rxsc::worker worker; + mutable std::deque chunks; + }; + std::shared_ptr state; + + buffer_with_time_observer(dest_type d, buffer_with_time_values v, coordinator_type c) + : state(std::make_shared(buffer_with_time_subscriber_values(std::move(d), v, std::move(c)))) + { + auto localState = state; + auto produce_buffer = [localState](const rxsc::schedulable& self) { + localState->dest.on_next(std::move(localState->chunks.front())); + localState->chunks.pop_front(); + }; + auto create_buffer = [localState, produce_buffer](const rxsc::schedulable& self) { + localState->chunks.emplace_back(); + localState->worker.schedule(localState->worker.now() + localState->period, produce_buffer); + self.schedule(localState->worker.now() + localState->skip); + }; + + state->chunks.emplace_back(); + state->worker.schedule(state->worker.now() + state->period, produce_buffer); + state->worker.schedule(state->worker.now() + state->skip, create_buffer); + } + void on_next(T v) const { + for(auto& chunk : state->chunks) { + chunk.push_back(v); + } + } + void on_error(std::exception_ptr e) const { + state->dest.on_error(e); + } + void on_completed() const { + auto done = on_exception( + [&](){ + while (!state->chunks.empty()) { + state->dest.on_next(std::move(state->chunks.front())); + state->chunks.pop_front(); + } + return true; + }, + state->dest); + if (done.empty()) { + return; + } + state->dest.on_completed(); + } + + static subscriber> make(dest_type d, buffer_with_time_values v) { + auto cs = d.get_subscription(); + auto coordinator = v.coordination.create_coordinator(cs); + + return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v), std::move(coordinator))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(buffer_with_time_observer::make(std::move(dest), initial)) { + return buffer_with_time_observer::make(std::move(dest), initial); + } +}; + +template +class buffer_with_time_factory +{ + typedef typename std::decay::type duration_type; + typedef typename std::decay::type coordination_type; + + duration_type period; + duration_type skip; + coordination_type coordination; +public: + buffer_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} + template + auto operator()(Observable&& source) + -> decltype(source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination))) { + return source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination)); + } +}; + +} + +template +inline auto buffer_with_time(Duration period, Coordination coordination) + -> detail::buffer_with_time_factory { + return detail::buffer_with_time_factory(period, period, coordination); +} + +template +inline auto buffer_with_time(Duration period, Duration skip, Coordination coordination) + -> detail::buffer_with_time_factory { + return detail::buffer_with_time_factory(period, skip, coordination); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 6014b4d..f6dee56 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -514,6 +514,48 @@ public: return lift>(rxo::detail::buffer_count(count, skip)); } + /// buffer_with_time -> + /// start a new vector every skip time interval and collect items into it from this observable for period of time. + /// + template + auto buffer_with_time(Duration period, Duration skip, Coordination coordination) const + -> typename std::enable_if< + is_coordination::value, + decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, skip, coordination)))>::type { + return lift>(rxo::detail::buffer_with_time(period, skip, coordination)); + } + + /// buffer_with_time -> + /// start a new vector every skip time interval and collect items into it from this observable for period of time. + /// + template + auto buffer_with_time(Duration period, Duration skip) const + -> typename std::enable_if< + !is_coordination::value, + decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, skip, identity_current_thread())))>::type { + return lift>(rxo::detail::buffer_with_time(period, skip, identity_current_thread())); + } + + /// buffer_with_time -> + /// start a new vector every period time interval and collect items into it from this observable for period of time. + /// + template + auto buffer_with_time(Duration period, Coordination coordination) const + -> typename std::enable_if< + is_coordination::value, + decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, period, coordination)))>::type { + return lift>(rxo::detail::buffer_with_time(period, period, coordination)); + } + + /// buffer_with_time -> + /// start a new vector every period time interval and collect items into it from this observable for period of time. + /// + template + auto buffer_with_time(Duration period) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, period, identity_current_thread()))) { + return lift>(rxo::detail::buffer_with_time(period, period, identity_current_thread())); + } + template struct defer_switch_on_next : public defer_observable< is_observable, diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 3b8d21a..762f366 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -35,6 +35,7 @@ namespace rxo=operators; } #include "operators/rx-buffer_count.hpp" +#include "operators/rx-buffer_time.hpp" #include "operators/rx-combine_latest.hpp" #include "operators/rx-concat.hpp" #include "operators/rx-concat_map.hpp" diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index 4a60877..072a2db 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -1,4 +1,5 @@ #include "rxcpp/rx.hpp" +namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxs=rxcpp::sources; namespace rxsc=rxcpp::schedulers; @@ -455,3 +456,506 @@ SCENARIO("buffer count error 2", "[buffer][operators]"){ } } } + +SCENARIO("buffer with time on intervals", "[buffer_with_time][operators][long][hide]"){ + GIVEN("7 intervals of 2 seconds"){ + WHEN("the period is 2sec and the initial is 5sec"){ + // time: |-----------------| + // events: 1 2 3 4 5 6 7 + // buffers: --- + // -1- + // 2-3 + // -4- + // 5-6 + // -7 + using namespace std::chrono; + typedef steady_clock clock; + + #define TIME milliseconds + #define UNIT *15 + + auto sc = rxsc::make_current_thread(); + auto so = rx::synchronize_in_one_worker(sc); + auto start = sc.now() + TIME(5 UNIT); + auto period = TIME(2 UNIT); + + rx::observable<>::interval(start, period, so) + .take(7) + .buffer_with_time(TIME(3 UNIT), so) + .subscribe( + [](std::vector counter){ + printf("on_next: "); + std::for_each(counter.begin(), counter.end(), [](long c){ + printf("%d ", c); + }); + printf("\n"); + }, + [](std::exception_ptr e){ + printf("on_error\n"); + }, + [](){ + printf("on_completed\n"); + } + ); + } + } +} + +SCENARIO("buffer with time on intervals, implicit coordination", "[buffer_with_time][operators][long][hide]"){ + GIVEN("7 intervals of 2 seconds"){ + WHEN("the period is 2sec and the initial is 5sec"){ + // time: |-----------------| + // events: 1 2 3 4 5 6 7 + // buffers: --- + // -1- + // 2-3 + // -4- + // 5-6 + // -7 + using namespace std::chrono; + typedef steady_clock clock; + + #define TIME milliseconds + #define UNIT *15 + + auto sc = rxsc::make_current_thread(); + auto so = rx::synchronize_in_one_worker(sc); + auto start = sc.now() + TIME(5 UNIT); + auto period = TIME(2 UNIT); + + rx::observable<>::interval(start, period, so) + .take(7) + .buffer_with_time(TIME(3 UNIT)) + .subscribe( + [](std::vector counter){ + printf("on_next: "); + std::for_each(counter.begin(), counter.end(), [](long c){ + printf("%d ", c); + }); + printf("\n"); + }, + [](std::exception_ptr e){ + printf("on_error\n"); + }, + [](){ + printf("on_completed\n"); + } + ); + } + } +} + +SCENARIO("buffer with time on overlapping intervals", "[buffer_with_time][operators][long][hide]"){ + GIVEN("5 intervals of 2 seconds"){ + WHEN("the period is 2sec and the initial is 5sec"){ + // time: |-------------| + // events: 1 2 3 4 5 + // buffers: ---- + // --1- + // 1-2- + // 2-3- + // 3-4- + // 4-5 + // 5 + using namespace std::chrono; + typedef steady_clock clock; + + #define TIME milliseconds + #define UNIT *15 + + auto sc = rxsc::make_current_thread(); + auto so = rx::synchronize_in_one_worker(sc); + auto start = sc.now() + TIME(5 UNIT); + auto period = TIME(2 UNIT); + + rx::observable<>::interval(start, period, so) + .take(5) + .buffer_with_time(TIME(4 UNIT), TIME(2 UNIT), so) + .subscribe( + [](std::vector counter){ + printf("on_next: "); + std::for_each(counter.begin(), counter.end(), [](long c){ + printf("%d ", c); + }); + printf("\n"); + }, + [](std::exception_ptr e){ + printf("on_error\n"); + }, + [](){ + printf("on_completed\n"); + } + ); + } + } +} + +SCENARIO("buffer with time on overlapping intervals, implicit coordination", "[buffer_with_time][operators][long][hide]"){ + GIVEN("5 intervals of 2 seconds"){ + WHEN("the period is 2sec and the initial is 5sec"){ + // time: |-------------| + // events: 1 2 3 4 5 + // buffers: ---- + // --1- + // 1-2- + // 2-3- + // 3-4- + // 4-5 + // 5 + using namespace std::chrono; + typedef steady_clock clock; + + #define TIME milliseconds + #define UNIT *15 + + auto sc = rxsc::make_current_thread(); + auto so = rx::synchronize_in_one_worker(sc); + auto start = sc.now() + TIME(5 UNIT); + auto period = TIME(2 UNIT); + + rx::observable<>::interval(start, period, so) + .take(5) + .buffer_with_time(TIME(4 UNIT), TIME(2 UNIT)) + .subscribe( + [](std::vector counter){ + printf("on_next: "); + std::for_each(counter.begin(), counter.end(), [](long c){ + printf("%d ", c); + }); + printf("\n"); + }, + [](std::exception_ptr e){ + printf("on_error\n"); + }, + [](){ + printf("on_completed\n"); + } + ); + } + } +} + +SCENARIO("buffer with time on intervals, error", "[buffer_with_time][operators][long][hide]"){ + GIVEN("5 intervals of 2 seconds"){ + WHEN("the period is 2sec and the initial is 5sec"){ + // time: |-------------| + // events: 1 2 3 4 5 + // buffers: ---- + // --1- + // 1-2- + // 2-3- + // 3-4- + // 4-5 + // 5 + using namespace std::chrono; + typedef steady_clock clock; + + #define TIME milliseconds + #define UNIT *15 + + auto sc = rxsc::make_current_thread(); + auto so = rx::synchronize_in_one_worker(sc); + auto start = sc.now() + TIME(5 UNIT); + auto period = TIME(2 UNIT); + + std::runtime_error ex("buffer_with_time on_error from source"); + + auto ys1 = rx::observable<>::interval(start, period, so).take(5); + auto ys2 = rx::observable<>::error(std::runtime_error("buffer_with_time on_error from source"), so); + ys1.concat(so, ys2) + .buffer_with_time(TIME(4 UNIT), TIME(2 UNIT), so) + .subscribe( + [](std::vector counter){ + printf("on_next: "); + std::for_each(counter.begin(), counter.end(), [](long c){ + printf("%d ", c); + }); + printf("\n"); + }, + [](std::exception_ptr e){ + printf("on_error\n"); + }, + [](){ + printf("on_completed\n"); + } + ); + } + } +} + +SCENARIO("buffer with time, overlapping intervals", "[buffer_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + WHEN("group ints on intersecting intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time(milliseconds(100), milliseconds(70), so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(300, rxu::to_vector({ 2, 3, 4 })), + v_on.next(370, rxu::to_vector({ 4, 5, 6 })), + v_on.next(440, rxu::to_vector({ 6, 7, 8 })), + v_on.next(510, rxu::to_vector({ 8, 9 })), + v_on.next(580, std::vector()), + v_on.next(600, std::vector()), + v_on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer with time, intervals with skips", "[buffer_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + WHEN("group ints on intervals with skips"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time(milliseconds(70), milliseconds(100), so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(270, rxu::to_vector({ 2, 3 })), + v_on.next(370, rxu::to_vector({ 5, 6 })), + v_on.next(470, rxu::to_vector({ 8, 9 })), + v_on.next(570, std::vector()), + v_on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer with time, error", "[buffer_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + std::runtime_error ex("buffer_with_time on_error from source"); + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) + }); + WHEN("group ints on intersecting intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time(milliseconds(100), milliseconds(70), so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(300, rxu::to_vector({ 2, 3, 4 })), + v_on.next(370, rxu::to_vector({ 4, 5, 6 })), + v_on.next(440, rxu::to_vector({ 6, 7, 8 })), + v_on.next(510, rxu::to_vector({ 8, 9 })), + v_on.next(580, std::vector()), + v_on.error(600, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer with time, disposed", "[buffer_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + WHEN("group ints on intersecting intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time(milliseconds(100), milliseconds(70), so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 370 + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(300, rxu::to_vector({ 2, 3, 4 })), + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 370) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer with time, same", "[buffer_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + WHEN("group ints on intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time(milliseconds(100), so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(300, rxu::to_vector({ 2, 3, 4 })), + v_on.next(400, rxu::to_vector({ 5, 6, 7 })), + v_on.next(500, rxu::to_vector({ 8, 9 })), + v_on.next(600, std::vector()), + v_on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From 808e95013052e90f6281d0a57ba77d484ee4cfa9 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 16 Sep 2014 19:21:15 +0400 Subject: [PATCH 429/782] Add window_with_time operator including tests. --- Rx/v2/src/rxcpp/operators/rx-window_time.hpp | 160 +++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 36 ++ Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/window.cpp | 443 +++++++++++++++++++ 4 files changed, 640 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-window_time.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp new file mode 100644 index 0000000..7981d8d --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -0,0 +1,160 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_WINDOW_WITH_TIME_HPP) +#define RXCPP_OPERATORS_RX_WINDOW_WITH_TIME_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct window_with_time +{ + typedef typename std::decay::type source_value_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + typedef typename std::decay::type duration_type; + + struct window_with_time_values + { + window_with_time_values(duration_type p, duration_type s, coordination_type c) + : period(p) + , skip(s) + , coordination(c) + { + } + duration_type period; + duration_type skip; + coordination_type coordination; + }; + window_with_time_values initial; + + window_with_time(duration_type period, duration_type skip, coordination_type coordination) + : initial(period, skip, coordination) + { + } + + template + struct window_with_time_observer : public observer_base> + { + typedef window_with_time_observer this_type; + typedef observer_base> base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + + struct window_with_time_subscriber_values : public window_with_time_values + { + window_with_time_subscriber_values(dest_type d, window_with_time_values v, coordinator_type c) + : window_with_time_values(v) + , dest(std::move(d)) + , coordinator(std::move(c)) + , worker(std::move(coordinator.get_worker())) + { + } + dest_type dest; + coordinator_type coordinator; + rxsc::worker worker; + mutable std::deque> subj; + }; + std::shared_ptr state; + + window_with_time_observer(dest_type d, window_with_time_values v, coordinator_type c) + : state(std::make_shared(window_with_time_subscriber_values(std::move(d), v, std::move(c)))) + { + auto localState = state; + auto release_window = [localState](const rxsc::schedulable& self) { + localState->subj[0].get_subscriber().on_completed(); + localState->subj.pop_front(); + }; + auto create_window = [localState, release_window](const rxsc::schedulable& self) { + localState->subj.push_back(rxcpp::subjects::subject()); + localState->dest.on_next(localState->subj[localState->subj.size() - 1].get_observable().as_dynamic()); + localState->worker.schedule(localState->worker.now() + localState->period, release_window); + self.schedule(localState->worker.now() + localState->skip); + }; + + state->subj.push_back(rxcpp::subjects::subject()); + state->dest.on_next(state->subj[0].get_observable().as_dynamic()); + state->worker.schedule(state->worker.now() + state->period, release_window); + state->worker.schedule(state->worker.now() + state->skip, create_window); + } + + void on_next(T v) const { + for (auto s : state->subj) { + s.get_subscriber().on_next(v); + } + } + + void on_error(std::exception_ptr e) const { + for (auto s : state->subj) { + s.get_subscriber().on_error(e); + } + state->dest.on_error(e); + } + + void on_completed() const { + for (auto s : state->subj) { + s.get_subscriber().on_completed(); + } + state->dest.on_completed(); + } + + static subscriber make(dest_type d, window_with_time_values v) { + auto cs = d.get_subscription(); + auto coordinator = v.coordination.create_coordinator(cs); + + return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(v), std::move(coordinator)))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(window_with_time_observer::make(std::move(dest), initial)) { + return window_with_time_observer::make(std::move(dest), initial); + } +}; + +template +class window_with_time_factory +{ + typedef typename std::decay::type duration_type; + typedef typename std::decay::type coordination_type; + + duration_type period; + duration_type skip; + coordination_type coordination; +public: + window_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} + template + auto operator()(Observable&& source) + -> decltype(source.template lift::type::value_type>>(window_with_time::type::value_type, Duration, Coordination>(period, skip, coordination))) { + return source.template lift::type::value_type>>(window_with_time::type::value_type, Duration, Coordination>(period, skip, coordination)); + } +}; + +} + +template +inline auto window_with_time(Duration period, Coordination coordination) + -> detail::window_with_time_factory { + return detail::window_with_time_factory(period, period, coordination); +} + +template +inline auto window_with_time(Duration period, Duration skip, Coordination coordination) + -> detail::window_with_time_factory { + return detail::window_with_time_factory(period, skip, coordination); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index f6dee56..a603b57 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -498,6 +498,42 @@ public: return lift>(rxo::detail::window(count, skip)); } + /// window_with_time -> + /// produce observables every skip time interval and collect items from this observable for period of time into each produced observable. + /// + template + auto window_with_time(Duration period, Duration skip, Coordination coordination) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window_with_time(period, skip, coordination))) { + return lift>(rxo::detail::window_with_time(period, skip, coordination)); + } + + /// window_with_time -> + /// produce observables every skip time interval and collect items from this observable for period of time into each produced observable. + /// + template + auto window_with_time(Duration period, Duration skip) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window_with_time(period, skip, identity_current_thread()))) { + return lift>(rxo::detail::window_with_time(period, skip, identity_current_thread())); + } + + /// window_with_time -> + /// produce observables every period time interval and collect items from this observable for period of time into each produced observable. + /// + template + auto window_with_time(Duration period, Coordination coordination) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window_with_time(period, period, coordination))) { + return lift>(rxo::detail::window_with_time(period, period, coordination)); + } + + /// window_with_time -> + /// produce observables every period time interval and collect items from this observable for period of time into each produced observable. + /// + template + auto window_with_time(Duration period) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window_with_time(period, period, identity_current_thread()))) { + return lift>(rxo::detail::window_with_time(period, period, identity_current_thread())); + } + /// buffer -> /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 762f366..b74d7a6 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -64,5 +64,6 @@ namespace rxo=operators; #include "operators/rx-take.hpp" #include "operators/rx-take_until.hpp" #include "operators/rx-window.hpp" +#include "operators/rx-window_time.hpp" #include "operators/rx-retry.hpp" #endif diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index 73ef113..12d32b1 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -305,3 +305,446 @@ SCENARIO("window count, error", "[window][operators]"){ } } } + +SCENARIO("window with time, basic", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.next(240, 3), + on.next(270, 4), + on.next(320, 5), + on.next(360, 6), + on.next(390, 7), + on.next(410, 8), + on.next(460, 9), + on.next(470, 10), + on.completed(490) + }); + + WHEN("group ints by 100 time units"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(100), milliseconds(50), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(270, 4), + on.next(270, 4), + on.next(320, 5), + on.next(320, 5), + on.next(360, 6), + on.next(360, 6), + on.next(390, 7), + on.next(390, 7), + on.next(410, 8), + on.next(410, 8), + on.next(460, 9), + on.next(460, 9), + on.next(470, 10), + on.next(470, 10), + on.completed(490) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 490) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time, basic same", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.next(240, 3), + on.next(270, 4), + on.next(320, 5), + on.next(360, 6), + on.next(390, 7), + on.next(410, 8), + on.next(460, 9), + on.next(470, 10), + on.completed(490) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(100), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(270, 4), + on.next(320, 5), + on.next(360, 6), + on.next(390, 7), + on.next(410, 8), + on.next(460, 9), + on.next(470, 10), + on.completed(490) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 490) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time, basic 1", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(100), milliseconds(70), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time, basic 2", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(70), milliseconds(100), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(320, 5), + on.next(350, 6), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time, error", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + std::runtime_error ex("window_with_time on_error from source"); + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(100), milliseconds(70), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time, disposed", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(100), milliseconds(70), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 370 + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(350, 6), + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 370) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time, basic same 1", "[window_with_time][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(100, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time(milliseconds(70), so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(380, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From 9f8ea67d455dda0093891c47e8f46dd72949a20c Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:29:57 -0700 Subject: [PATCH 430/782] silence warning on clang --- Rx/v2/src/rxcpp/rx-notification.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index fb23c36..064851a 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -95,7 +95,7 @@ inline std::ostream& operator<< (std::ostream& os, const std::vector& v) { template auto equals(const T& lhs, const T& rhs, int) - -> decltype(lhs == rhs, true) { + -> decltype(bool(lhs == rhs)) { return lhs == rhs; } -- GitLab From ece01804a783ed407f0b54702779bbe2e0a4072a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:30:39 -0700 Subject: [PATCH 431/782] fix clang errors in printf specs --- Rx/v2/test/operators/buffer.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index 072a2db..eb71572 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -473,7 +473,7 @@ SCENARIO("buffer with time on intervals", "[buffer_with_time][operators][long][h #define TIME milliseconds #define UNIT *15 - + auto sc = rxsc::make_current_thread(); auto so = rx::synchronize_in_one_worker(sc); auto start = sc.now() + TIME(5 UNIT); @@ -486,7 +486,7 @@ SCENARIO("buffer with time on intervals", "[buffer_with_time][operators][long][h [](std::vector counter){ printf("on_next: "); std::for_each(counter.begin(), counter.end(), [](long c){ - printf("%d ", c); + printf("%ld ", c); }); printf("\n"); }, @@ -517,7 +517,7 @@ SCENARIO("buffer with time on intervals, implicit coordination", "[buffer_with_t #define TIME milliseconds #define UNIT *15 - + auto sc = rxsc::make_current_thread(); auto so = rx::synchronize_in_one_worker(sc); auto start = sc.now() + TIME(5 UNIT); @@ -530,7 +530,7 @@ SCENARIO("buffer with time on intervals, implicit coordination", "[buffer_with_t [](std::vector counter){ printf("on_next: "); std::for_each(counter.begin(), counter.end(), [](long c){ - printf("%d ", c); + printf("%ld ", c); }); printf("\n"); }, @@ -562,7 +562,7 @@ SCENARIO("buffer with time on overlapping intervals", "[buffer_with_time][operat #define TIME milliseconds #define UNIT *15 - + auto sc = rxsc::make_current_thread(); auto so = rx::synchronize_in_one_worker(sc); auto start = sc.now() + TIME(5 UNIT); @@ -575,7 +575,7 @@ SCENARIO("buffer with time on overlapping intervals", "[buffer_with_time][operat [](std::vector counter){ printf("on_next: "); std::for_each(counter.begin(), counter.end(), [](long c){ - printf("%d ", c); + printf("%ld ", c); }); printf("\n"); }, @@ -607,7 +607,7 @@ SCENARIO("buffer with time on overlapping intervals, implicit coordination", "[b #define TIME milliseconds #define UNIT *15 - + auto sc = rxsc::make_current_thread(); auto so = rx::synchronize_in_one_worker(sc); auto start = sc.now() + TIME(5 UNIT); @@ -620,7 +620,7 @@ SCENARIO("buffer with time on overlapping intervals, implicit coordination", "[b [](std::vector counter){ printf("on_next: "); std::for_each(counter.begin(), counter.end(), [](long c){ - printf("%d ", c); + printf("%ld ", c); }); printf("\n"); }, @@ -652,7 +652,7 @@ SCENARIO("buffer with time on intervals, error", "[buffer_with_time][operators][ #define TIME milliseconds #define UNIT *15 - + auto sc = rxsc::make_current_thread(); auto so = rx::synchronize_in_one_worker(sc); auto start = sc.now() + TIME(5 UNIT); @@ -668,7 +668,7 @@ SCENARIO("buffer with time on intervals, error", "[buffer_with_time][operators][ [](std::vector counter){ printf("on_next: "); std::for_each(counter.begin(), counter.end(), [](long c){ - printf("%d ", c); + printf("%ld ", c); }); printf("\n"); }, -- GitLab From bc96604bc2573e9e977995201c69475b6fec15ec Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:33:42 -0700 Subject: [PATCH 432/782] add types_checked based on void_t proposal --- Rx/v2/src/rxcpp/rx-util.hpp | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 470b532..1d265c7 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -79,6 +79,31 @@ struct all_true static const bool value = B0 && all_true::value; }; +// +// based on Walter Brown's void_t proposal +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3911.pdf +// + +struct types_checked {}; + +namespace detail { +template struct types_checked_from {typedef types_checked type;}; +} + +template +struct types_checked_from {typedef typename detail::types_checked_from::type type;}; + + + +template +struct value_type_from : public std::false_type {typedef types_checked type;}; + +template +struct value_type_from::type> + : public std::true_type {typedef typename T::value_type type;}; + + + namespace detail { template -- GitLab From 63ecc901bcaf85358221fc4329d0ce2f95b1789e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:34:53 -0700 Subject: [PATCH 433/782] add some types_checked usage --- Rx/v2/src/rxcpp/rx-coordination.hpp | 30 ++++++++++++----------------- Rx/v2/src/rxcpp/rx-predef.hpp | 16 ++++++--------- 2 files changed, 18 insertions(+), 28 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index abd1506..23c5405 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -11,29 +11,23 @@ namespace rxcpp { struct tag_coordinator {}; struct coordinator_base {typedef tag_coordinator coordinator_tag;}; + +template +struct is_coordinator : public std::false_type {}; + template -class is_coordinator -{ - template - static typename C::coordinator_tag* check(int); - template - static void check(...); -public: - static const bool value = std::is_convertible::type>(0)), tag_coordinator*>::value; -}; +struct is_coordinator::type> + : public std::is_convertible {}; struct tag_coordination {}; struct coordination_base {typedef tag_coordination coordination_tag;}; + +template +struct is_coordination : public std::false_type {}; + template -class is_coordination -{ - template - static typename C::coordination_tag* check(int); - template - static void check(...); -public: - static const bool value = std::is_convertible::type>(0)), tag_coordination*>::value; -}; +struct is_coordination::type> + : public std::is_convertible {}; template class coordinator : public coordinator_base diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index bd94151..634b73f 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -19,17 +19,13 @@ inline auto trace_activity() -> decltype(rxcpp_trace_activity(trace_tag()))& { struct tag_action {}; +template +struct is_action : public std::false_type {}; + template -class is_action -{ - struct not_void {}; - template - static typename C::action_tag* check(int); - template - static not_void check(...); -public: - static const bool value = std::is_convertible::type>(0)), tag_action*>::value; -}; +struct is_action::type> + : public std::is_convertible {}; + struct tag_worker {}; template -- GitLab From b70b84b8ff95065c9225d9deed9b40a7ccc23895 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:36:09 -0700 Subject: [PATCH 434/782] fix clang errors --- Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp | 9 ++- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 5 +- Rx/v2/src/rxcpp/operators/rx-window_time.hpp | 4 +- Rx/v2/src/rxcpp/rx-observable.hpp | 69 ++++++++++++-------- 4 files changed, 54 insertions(+), 33 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp index f6766d7..c580af8 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -16,6 +16,9 @@ namespace detail { template struct buffer_with_time { + static_assert(std::is_convertible::value, "Duration parameter must convert to rxsc::scheduler::clock_type::duration"); + static_assert(is_coordination::value, "Coordination parameter must satisfy the requirements for a Coordination"); + typedef typename std::decay::type source_value_type; typedef typename std::decay::type coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; @@ -41,7 +44,7 @@ struct buffer_with_time } template - struct buffer_with_time_observer + struct buffer_with_time_observer { typedef buffer_with_time_observer this_type; typedef std::vector value_type; @@ -134,8 +137,8 @@ public: buffer_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination))) { + return source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index 08cd629..d91d43e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -23,7 +23,7 @@ struct is_lift_function_for { typedef typename std::decay::type for_type; typedef typename std::decay::type func_type; typedef decltype(check(0)) detail_result; - static const bool value = is_subscriber::value && is_subscriber::value && std::is_convertible::value; + static const bool value = is_subscriber::value && is_subscriber::value && std::is_convertible::type>::value; }; } @@ -41,7 +41,7 @@ struct lift_traits typedef typename source_operator_type::value_type source_value_type; - static_assert(rxcpp::detail::is_lift_function_for, operator_type>::value, "lift Operator must be a function with the signature subscriber(subscriber)"); + static const bool value = rxcpp::detail::is_lift_function_for, operator_type>::value; }; template @@ -78,6 +78,7 @@ public: auto operator()(Observable&& source) -> decltype(source.template lift(chain)) { return source.template lift(chain); + static_assert(rxcpp::detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp index 7981d8d..4bd9c68 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -144,13 +144,13 @@ public: template inline auto window_with_time(Duration period, Coordination coordination) -> detail::window_with_time_factory { - return detail::window_with_time_factory(period, period, coordination); + return detail::window_with_time_factory(period, period, coordination); } template inline auto window_with_time(Duration period, Duration skip, Coordination coordination) -> detail::window_with_time_factory { - return detail::window_with_time_factory(period, skip, coordination); + return detail::window_with_time_factory(period, skip, coordination); } } diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index a603b57..1561c8e 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -432,6 +432,30 @@ public: static_assert(detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); } + /// + /// takes any function that will take a subscriber for this observable and produce a subscriber. + /// this is intended to allow externally defined operators, that use make_subscriber, to be connected + /// into the expression. + /// + template + auto lift_if(Operator&& op) const + -> typename std::enable_if, Operator>::value, + observable::value_type, rxo::detail::lift_operator>>::type { + return observable::value_type, rxo::detail::lift_operator>( + rxo::detail::lift_operator(source_operator, std::forward(op))); + } + /// + /// takes any function that will take a subscriber for this observable and produce a subscriber. + /// this is intended to allow externally defined operators, that use make_subscriber, to be connected + /// into the expression. + /// + template + auto lift_if(Operator&& op) const + -> typename std::enable_if, Operator>::value, + decltype(rxs::from())>::type { + return rxs::from(); + } + /// /// subscribe will cause this observable to emit values to the provided subscriber. /// callers must provide enough arguments to make a subscriber. @@ -538,58 +562,51 @@ public: /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// auto buffer(int count) const - -> decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_count(count, count))) { - return lift>(rxo::detail::buffer_count(count, count)); + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_count(count, count))) { + return lift_if>(rxo::detail::buffer_count(count, count)); } /// buffer -> /// start a new vector every skip items and collect count items from this observable into each vector to emit from the new observable that is returned. /// auto buffer(int count, int skip) const - -> decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_count(count, skip))) { - return lift>(rxo::detail::buffer_count(count, skip)); + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_count(count, skip))) { + return lift_if>(rxo::detail::buffer_count(count, skip)); } /// buffer_with_time -> /// start a new vector every skip time interval and collect items into it from this observable for period of time. /// - template - auto buffer_with_time(Duration period, Duration skip, Coordination coordination) const - -> typename std::enable_if< - is_coordination::value, - decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, skip, coordination)))>::type { - return lift>(rxo::detail::buffer_with_time(period, skip, coordination)); + template + auto buffer_with_time(rxsc::scheduler::clock_type::duration period, rxsc::scheduler::clock_type::duration skip, Coordination coordination) const + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_with_time(period, skip, coordination))) { + return lift_if>(rxo::detail::buffer_with_time(period, skip, coordination)); } /// buffer_with_time -> /// start a new vector every skip time interval and collect items into it from this observable for period of time. /// - template - auto buffer_with_time(Duration period, Duration skip) const - -> typename std::enable_if< - !is_coordination::value, - decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, skip, identity_current_thread())))>::type { - return lift>(rxo::detail::buffer_with_time(period, skip, identity_current_thread())); + auto buffer_with_time(rxsc::scheduler::clock_type::duration period, rxsc::scheduler::clock_type::duration skip) const + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_with_time(period, skip, identity_current_thread()))) { + return lift_if>(rxo::detail::buffer_with_time(period, skip, identity_current_thread())); } /// buffer_with_time -> /// start a new vector every period time interval and collect items into it from this observable for period of time. /// - template - auto buffer_with_time(Duration period, Coordination coordination) const - -> typename std::enable_if< - is_coordination::value, - decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, period, coordination)))>::type { - return lift>(rxo::detail::buffer_with_time(period, period, coordination)); + template::value, rxu::types_checked>::type> + auto buffer_with_time(rxsc::scheduler::clock_type::duration period, Coordination coordination) const + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_with_time(period, period, coordination))) { + return lift_if>(rxo::detail::buffer_with_time(period, period, coordination)); } /// buffer_with_time -> /// start a new vector every period time interval and collect items into it from this observable for period of time. /// - template - auto buffer_with_time(Duration period) const - -> decltype(EXPLICIT_THIS lift>(rxo::detail::buffer_with_time(period, period, identity_current_thread()))) { - return lift>(rxo::detail::buffer_with_time(period, period, identity_current_thread())); + auto buffer_with_time(rxsc::scheduler::clock_type::duration period) const + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_with_time(period, period, identity_current_thread()))) { + return lift_if>(rxo::detail::buffer_with_time(period, period, identity_current_thread())); } template -- GitLab From bc7a99ab4945fa21a31971b15b6a57d9fe062f1d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:39:44 -0700 Subject: [PATCH 435/782] stop time drift in buffer_with_time --- Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp index c580af8..a14e854 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -58,12 +58,14 @@ struct buffer_with_time , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) + , expected(worker.now()) { } dest_type dest; coordinator_type coordinator; rxsc::worker worker; mutable std::deque chunks; + rxsc::scheduler::clock_type::time_point expected; }; std::shared_ptr state; @@ -75,15 +77,17 @@ struct buffer_with_time localState->dest.on_next(std::move(localState->chunks.front())); localState->chunks.pop_front(); }; - auto create_buffer = [localState, produce_buffer](const rxsc::schedulable& self) { + auto create_buffer = [localState, produce_buffer](const rxsc::schedulable&) { localState->chunks.emplace_back(); - localState->worker.schedule(localState->worker.now() + localState->period, produce_buffer); - self.schedule(localState->worker.now() + localState->skip); + auto produce_at = localState->expected + localState->period; + localState->expected += localState->skip; + localState->worker.schedule(produce_at, produce_buffer); }; - state->chunks.emplace_back(); - state->worker.schedule(state->worker.now() + state->period, produce_buffer); - state->worker.schedule(state->worker.now() + state->skip, create_buffer); + state->worker.schedule_periodically( + state->expected, + state->skip, + create_buffer); } void on_next(T v) const { for(auto& chunk : state->chunks) { -- GitLab From 9ef6110f9e5e93eac8d0f0fdd5be78be29c0a233 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 18 Sep 2014 21:45:21 -0700 Subject: [PATCH 436/782] stop time drift in window_with_time --- Rx/v2/src/rxcpp/operators/rx-window_time.hpp | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp index 4bd9c68..aa01caa 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -56,12 +56,14 @@ struct window_with_time , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) + , expected(worker.now()) { } dest_type dest; coordinator_type coordinator; rxsc::worker worker; mutable std::deque> subj; + rxsc::scheduler::clock_type::time_point expected; }; std::shared_ptr state; @@ -73,17 +75,19 @@ struct window_with_time localState->subj[0].get_subscriber().on_completed(); localState->subj.pop_front(); }; - auto create_window = [localState, release_window](const rxsc::schedulable& self) { + auto create_window = [localState, release_window](const rxsc::schedulable&) { localState->subj.push_back(rxcpp::subjects::subject()); localState->dest.on_next(localState->subj[localState->subj.size() - 1].get_observable().as_dynamic()); - localState->worker.schedule(localState->worker.now() + localState->period, release_window); - self.schedule(localState->worker.now() + localState->skip); + + auto produce_at = localState->expected + localState->period; + localState->expected += localState->skip; + localState->worker.schedule(produce_at, release_window); }; - state->subj.push_back(rxcpp::subjects::subject()); - state->dest.on_next(state->subj[0].get_observable().as_dynamic()); - state->worker.schedule(state->worker.now() + state->period, release_window); - state->worker.schedule(state->worker.now() + state->skip, create_window); + state->worker.schedule_periodically( + state->expected, + state->skip, + create_window); } void on_next(T v) const { -- GitLab From 532cb26023a8d89799680144cfd44655b697373d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 19 Sep 2014 07:34:25 -0700 Subject: [PATCH 437/782] fix clang error --- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index d91d43e..58fa4d6 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -75,7 +75,7 @@ class lift_factory public: lift_factory(operator_type op) : chain(std::move(op)) {} template - auto operator()(Observable&& source) + auto operator()(const Observable& source) -> decltype(source.template lift(chain)) { return source.template lift(chain); static_assert(rxcpp::detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); -- GitLab From cb6ef300af1435ad19475b97817942ccabe37fe5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 19 Sep 2014 07:34:49 -0700 Subject: [PATCH 438/782] ci script update --- projects/scripts/travis-install.sh | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 466c1fa..2cfcd39 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -8,26 +8,26 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then sudo add-apt-repository -y 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise main' sudo add-apt-repository -y ppa:28msec/utils # Recent cmake sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang-3.5 - sudo apt-get clean - sudo apt-get update + sudo apt-get clean -qq || echo "ignore clean failure" + sudo apt-get update -qq || echo "ignore update failure" - sudo apt-get install -q --fix-missing cmake libssl-dev + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing cmake libssl-dev if [ "$CC" = clang ]; then - sudo apt-get install -q --fix-missing clang-3.6 + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.6 sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.6 20 sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.6 20 fi if [ "$CC" = gcc ]; then - sudo apt-get install -q --fix-missing gcc-4.8 g++-4.8 + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing gcc-4.8 g++-4.8 sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 fi elif [ "$TRAVIS_OS_NAME" = osx ]; then xcode-select --install - brew update - brew doctor - brew list cmake || brew install cmake + brew update || echo "suppress failures in order to ignore warnings" + brew doctor || echo "suppress failures in order to ignore warnings" + brew list cmake || brew install cmake || echo "suppress failures in order to ignore warnings" fi -- GitLab From 0ecee09a6fbc9f0062dac7342b47279db0e48898 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 2 Oct 2014 20:57:27 -0700 Subject: [PATCH 439/782] fix some warnings --- Rx/v2/test/operators/concat_map.cpp | 18 +++---- Rx/v2/test/operators/filter.cpp | 6 +-- Rx/v2/test/operators/flat_map.cpp | 18 +++---- Rx/v2/test/operators/publish.cpp | 50 +++++++++---------- Rx/v2/test/operators/window.cpp | 4 +- Rx/v2/test/sources/scope.cpp | 7 ++- Rx/v2/test/subjects/subject.cpp | 60 +++++++++++------------ Rx/v2/test/subscriptions/subscription.cpp | 21 ++++---- 8 files changed, 93 insertions(+), 91 deletions(-) diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 0d3402c..8423e46 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -36,14 +36,14 @@ SCENARIO("concat_map pythagorian ranges", "[hide][range][concat_map][pythagorian .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}) + [](int /*x*/, std::tuple triplet){return triplet;}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}); + [](int /*z*/, std::tuple triplet){return triplet;}); triples .take(tripletCount) .subscribe( - rxu::apply_to([&ct](int x,int y,int z){++ct;}), + rxu::apply_to([&ct](int /*x*/,int /*y*/,int /*z*/){++ct;}), [](std::exception_ptr){abort();}); auto finish = clock::now(); auto msElapsed = duration_cast(finish.time_since_epoch()) - @@ -83,11 +83,11 @@ SCENARIO("synchronize concat_map pythagorian ranges", "[hide][range][concat_map] .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}, + [](int /*x*/, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}, + [](int /*z*/, std::tuple triplet){return triplet;}, so); int ct = triples .take(tripletCount) @@ -131,11 +131,11 @@ SCENARIO("observe_on concat_map pythagorian ranges", "[hide][range][concat_map][ .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}, + [](int /*x*/, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}, + [](int /*z*/, std::tuple triplet){return triplet;}, so); int ct = triples @@ -180,11 +180,11 @@ SCENARIO("serialize concat_map pythagorian ranges", "[hide][range][concat_map][s .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}, + [](int /*x*/, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}, + [](int /*z*/, std::tuple triplet){return triplet;}, so); int ct = triples diff --git a/Rx/v2/test/operators/filter.cpp b/Rx/v2/test/operators/filter.cpp index fdab02a..accb527 100644 --- a/Rx/v2/test/operators/filter.cpp +++ b/Rx/v2/test/operators/filter.cpp @@ -370,7 +370,7 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") WHEN("filtered to ints that are primes"){ w.schedule_absolute(rxsc::test::created_time, - [&invoked, &res, &ys, &xs](const rxsc::schedulable& scbl) { + [&invoked, &res, &ys, &xs](const rxsc::schedulable&) { #if RXCPP_USE_OBSERVABLE_MEMBERS ys = xs .filter([&invoked, &res](int x) { @@ -390,11 +390,11 @@ SCENARIO("filter stops on dispose from predicate", "[where][filter][operators]") #endif }); - w.schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable& scbl) { + w.schedule_absolute(rxsc::test::subscribed_time, [&ys, &res](const rxsc::schedulable&) { ys.subscribe(res); }); - w.schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable& scbl) { + w.schedule_absolute(rxsc::test::unsubscribed_time, [&res](const rxsc::schedulable&) { res.unsubscribe(); }); diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 8490de8..44b6869 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -71,14 +71,14 @@ SCENARIO("flat_map pythagorian ranges", "[hide][range][flat_map][pythagorian][pe .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}) + [](int /*x*/, std::tuple triplet){return triplet;}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}); + [](int /*z*/, std::tuple triplet){return triplet;}); triples .take(tripletCount) .subscribe( - rxu::apply_to([&ct](int x,int y,int z){ + rxu::apply_to([&ct](int /*x*/,int /*y*/,int /*z*/){ ++ct; })); auto finish = clock::now(); @@ -119,11 +119,11 @@ SCENARIO("synchronize flat_map pythagorian ranges", "[hide][range][flat_map][syn .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}, + [](int /*x*/, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}, + [](int /*z*/, std::tuple triplet){return triplet;}, so); int ct = triples .take(tripletCount) @@ -167,11 +167,11 @@ SCENARIO("observe_on flat_map pythagorian ranges", "[hide][range][flat_map][obse .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}, + [](int /*x*/, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}, + [](int /*z*/, std::tuple triplet){return triplet;}, so); int ct = triples .take(tripletCount) @@ -215,11 +215,11 @@ SCENARIO("serialize flat_map pythagorian ranges", "[hide][range][flat_map][seria .map([z, x](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}, + [](int /*x*/, std::tuple triplet){return triplet;}, so) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}, + [](int /*z*/, std::tuple triplet){return triplet;}, so); int ct = triples .take(tripletCount) diff --git a/Rx/v2/test/operators/publish.cpp b/Rx/v2/test/operators/publish.cpp index 27bc574..0a22309 100644 --- a/Rx/v2/test/operators/publish.cpp +++ b/Rx/v2/test/operators/publish.cpp @@ -72,18 +72,18 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ WHEN("subscribed and then connected"){ w.schedule_absolute(rxsc::test::created_time, - [&ys, &xs](const rxsc::schedulable& scbl){ + [&ys, &xs](const rxsc::schedulable&){ ys = xs.publish().as_dynamic(); //ys = xs.publish_last().as_dynamic(); }); w.schedule_absolute(rxsc::test::subscribed_time, - [&ys, &res](const rxsc::schedulable& scbl){ + [&ys, &res](const rxsc::schedulable&){ ys.subscribe(res); }); w.schedule_absolute(rxsc::test::unsubscribed_time, - [&res](const rxsc::schedulable& scbl){ + [&res](const rxsc::schedulable&){ res.unsubscribe(); }); @@ -91,11 +91,11 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ rx::composite_subscription connection; w.schedule_absolute(300, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(400, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -104,11 +104,11 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ rx::composite_subscription connection; w.schedule_absolute(500, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(550, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -117,11 +117,11 @@ SCENARIO("publish basic", "[publish][multicast][subject][operators]"){ rx::composite_subscription connection; w.schedule_absolute(650, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(800, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -187,17 +187,17 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ WHEN("subscribed and then connected"){ w.schedule_absolute(rxsc::test::created_time, - [&ys, &xs](const rxsc::schedulable& scbl){ + [&ys, &xs](const rxsc::schedulable&){ ys = xs.publish().as_dynamic(); }); w.schedule_absolute(rxsc::test::subscribed_time, - [&ys, &res](const rxsc::schedulable& scbl){ + [&ys, &res](const rxsc::schedulable&){ ys.subscribe(res); }); w.schedule_absolute(rxsc::test::unsubscribed_time, - [&res](const rxsc::schedulable& scbl){ + [&res](const rxsc::schedulable&){ res.unsubscribe(); }); @@ -205,11 +205,11 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ rx::composite_subscription connection; w.schedule_absolute(300, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(400, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -218,11 +218,11 @@ SCENARIO("publish error", "[publish][error][multicast][subject][operators]"){ rx::composite_subscription connection; w.schedule_absolute(500, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(800, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -286,17 +286,17 @@ SCENARIO("publish basic with initial value", "[publish][multicast][behavior][ope WHEN("subscribed and then connected"){ w.schedule_absolute(rxsc::test::created_time, - [&ys, &xs](const rxsc::schedulable& scbl){ + [&ys, &xs](const rxsc::schedulable&){ ys = xs.publish(1979).as_dynamic(); }); w.schedule_absolute(rxsc::test::subscribed_time, - [&ys, &res](const rxsc::schedulable& scbl){ + [&ys, &res](const rxsc::schedulable&){ ys.subscribe(res); }); w.schedule_absolute(rxsc::test::unsubscribed_time, - [&res](const rxsc::schedulable& scbl){ + [&res](const rxsc::schedulable&){ res.unsubscribe(); }); @@ -304,11 +304,11 @@ SCENARIO("publish basic with initial value", "[publish][multicast][behavior][ope rx::composite_subscription connection; w.schedule_absolute(300, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(400, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -317,11 +317,11 @@ SCENARIO("publish basic with initial value", "[publish][multicast][behavior][ope rx::composite_subscription connection; w.schedule_absolute(500, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(550, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } @@ -330,11 +330,11 @@ SCENARIO("publish basic with initial value", "[publish][multicast][behavior][ope rx::composite_subscription connection; w.schedule_absolute(650, - [connection, &ys](const rxsc::schedulable& scbl){ + [connection, &ys](const rxsc::schedulable&){ ys.connect(connection); }); w.schedule_absolute(800, - [connection](const rxsc::schedulable& scbl){ + [connection](const rxsc::schedulable&){ connection.unsubscribe(); }); } diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index 12d32b1..141a07c 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -97,7 +97,7 @@ SCENARIO("window count, inner timings", "[window][operators]"){ w.schedule_absolute( rxsc::test::created_time, - [&](const rxsc::schedulable& scbl) { + [&](const rxsc::schedulable&) { res = xs .window(3, 2); } @@ -105,7 +105,7 @@ SCENARIO("window count, inner timings", "[window][operators]"){ w.schedule_absolute( rxsc::test::subscribed_time, - [&](const rxsc::schedulable& scbl) { + [&](const rxsc::schedulable&) { res.subscribe( // on_next [&](rx::observable window) { diff --git a/Rx/v2/test/sources/scope.cpp b/Rx/v2/test/sources/scope.cpp index cca805d..ac3fc16 100644 --- a/Rx/v2/test/sources/scope.cpp +++ b/Rx/v2/test/sources/scope.cpp @@ -343,10 +343,10 @@ SCENARIO("scope, throw resource selector", "[scope][sources]"){ [&]() { return rx::observable<>:: scope( - [&](){ + [&]() -> resource { ++resource_factory_invoked; throw ex; - return resource(sc.clock()); + //return resource(sc.clock()); }, [&](resource r){ ++observable_factory_invoked; @@ -400,10 +400,9 @@ SCENARIO("scope, throw resource usage", "[scope][sources]"){ ++resource_factory_invoked; return resource(sc.clock()); }, - [&](resource r){ + [&](resource r) -> rx::observable { ++observable_factory_invoked; throw ex; - return rx::observable<>::never(); } ) // forget type to workaround lambda deduction bug on msvc 2013 diff --git a/Rx/v2/test/subjects/subject.cpp b/Rx/v2/test/subjects/subject.cpp index dd097d8..e1e91a0 100644 --- a/Rx/v2/test/subjects/subject.cpp +++ b/Rx/v2/test/subjects/subject.cpp @@ -467,27 +467,27 @@ SCENARIO("subject - infinite source", "[subject][subjects]"){ auto o = s.get_subscriber(); - w.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(100, [&s, &o](const rxsc::schedulable&){ s = rxsub::subject(); o = s.get_subscriber();}); - w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable&){ xs.subscribe(o);}); - w.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + w.schedule_absolute(1000, [&o](const rxsc::schedulable&){ o.unsubscribe();}); - w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable&){ s.get_observable().subscribe(results1);}); - w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable&){ s.get_observable().subscribe(results2);}); - w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable&){ s.get_observable().subscribe(results3);}); - w.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(600, [&results1](const rxsc::schedulable&){ results1.unsubscribe();}); - w.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(700, [&results2](const rxsc::schedulable&){ results2.unsubscribe();}); - w.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(800, [&results1](const rxsc::schedulable&){ results1.unsubscribe();}); - w.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(950, [&results3](const rxsc::schedulable&){ results3.unsubscribe();}); w.start(); @@ -557,27 +557,27 @@ SCENARIO("subject - finite source", "[subject][subjects]"){ auto o = s.get_subscriber(); - w.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(100, [&s, &o](const rxsc::schedulable&){ s = rxsub::subject(); o = s.get_subscriber();}); - w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable&){ xs.subscribe(o);}); - w.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + w.schedule_absolute(1000, [&o](const rxsc::schedulable&){ o.unsubscribe();}); - w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable&){ s.get_observable().subscribe(results1);}); - w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable&){ s.get_observable().subscribe(results2);}); - w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable&){ s.get_observable().subscribe(results3);}); - w.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(600, [&results1](const rxsc::schedulable&){ results1.unsubscribe();}); - w.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(700, [&results2](const rxsc::schedulable&){ results2.unsubscribe();}); - w.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(800, [&results1](const rxsc::schedulable&){ results1.unsubscribe();}); - w.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(950, [&results3](const rxsc::schedulable&){ results3.unsubscribe();}); w.start(); @@ -650,27 +650,27 @@ SCENARIO("subject - on_error in source", "[subject][subjects]"){ auto o = s.get_subscriber(); - w.schedule_absolute(100, [&s, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(100, [&s, &o](const rxsc::schedulable&){ s = rxsub::subject(); o = s.get_subscriber();}); - w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable& scbl){ + w.schedule_absolute(200, [&xs, &o](const rxsc::schedulable&){ xs.subscribe(o);}); - w.schedule_absolute(1000, [&o](const rxsc::schedulable& scbl){ + w.schedule_absolute(1000, [&o](const rxsc::schedulable&){ o.unsubscribe();}); - w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(300, [&s, &results1](const rxsc::schedulable&){ s.get_observable().subscribe(results1);}); - w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(400, [&s, &results2](const rxsc::schedulable&){ s.get_observable().subscribe(results2);}); - w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(900, [&s, &results3](const rxsc::schedulable&){ s.get_observable().subscribe(results3);}); - w.schedule_absolute(600, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(600, [&results1](const rxsc::schedulable&){ results1.unsubscribe();}); - w.schedule_absolute(700, [&results2](const rxsc::schedulable& scbl){ + w.schedule_absolute(700, [&results2](const rxsc::schedulable&){ results2.unsubscribe();}); - w.schedule_absolute(800, [&results1](const rxsc::schedulable& scbl){ + w.schedule_absolute(800, [&results1](const rxsc::schedulable&){ results1.unsubscribe();}); - w.schedule_absolute(950, [&results3](const rxsc::schedulable& scbl){ + w.schedule_absolute(950, [&results3](const rxsc::schedulable&){ results3.unsubscribe();}); w.start(); diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 6919b63..37c3683 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -34,7 +34,7 @@ SCENARIO("for loop subscribes to map", "[hide][for][just][subscribe][long][perf] std::stringstream(s) >> i; return i; }) - .subscribe([&](int i){ + .subscribe([&](int){ ++c; }); } @@ -52,6 +52,7 @@ SCENARIO("for loop subscribes to map", "[hide][for][just][subscribe][long][perf] } } +#if 0 SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_latest][subscribe][long][perf]"){ const int& subscriptions = static_subscriptions; GIVEN("a for loop"){ @@ -89,6 +90,7 @@ SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_lat } } } +#endif SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug][synchronize][long][perf]"){ GIVEN("range"){ @@ -124,7 +126,6 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug }, [=](std::exception_ptr e){ abort(); - std::get<2>(*completionstate).on_error(e); }, [=](){ if (std::get<1>(*completionstate) != values) { @@ -146,7 +147,7 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( - [&](int i){ + [&](int){ ++v; }, [&](){ @@ -161,7 +162,7 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( - [&](int i){ + [&](int){ ++v; }, [&](){ @@ -176,7 +177,7 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( - [&](int i){ + [&](int){ ++v; }, [&](){ @@ -234,7 +235,6 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o }, [=](std::exception_ptr e){ abort(); - std::get<2>(*completionstate).on_error(e); }, [=](){ if (std::get<1>(*completionstate) != values) { @@ -255,7 +255,7 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( - [&](int i){ + [&](int){ ++v; }, [&](){ @@ -269,7 +269,7 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( - [&](int i){ + [&](int){ ++v; }, [&](){ @@ -283,7 +283,7 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o .lift(liftrequirecompletion) .subscribe( rx::make_observer_dynamic( - [&](int i){ + [&](int){ ++v; }, [&](){ @@ -329,12 +329,15 @@ SCENARIO("non-subscription traits", "[subscription][traits]"){ void* v = nullptr; WHEN("tested"){ THEN("is_subscription value is false for lambda"){ + l(); REQUIRE(!rx::is_subscription::value); } THEN("is_subscription value is false for int"){ + i = 0; REQUIRE(!rx::is_subscription::value); } THEN("is_subscription value is false for void*"){ + v = nullptr; REQUIRE(!rx::is_subscription::value); } THEN("is_subscription value is false for void"){ -- GitLab From d859663d764f41197def026ae4a789fff2cf6c55 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 2 Oct 2014 20:59:30 -0700 Subject: [PATCH 440/782] add RXCPP_DELETE and types<...> --- Rx/v2/src/rxcpp/rx-util.hpp | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 1d265c7..b6de101 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -23,6 +23,14 @@ #endif #endif +#if !defined(RXCPP_DELETE) +#if defined(_MSC_VER) +#define RXCPP_DELETE __pragma(warning(disable: 4822)) =delete +#else +#define RXCPP_DELETE =delete +#endif +#endif + #define RXCPP_CONCAT(Prefix, Suffix) Prefix ## Suffix #define RXCPP_CONCAT_EVALUATE(Prefix, Suffix) RXCPP_CONCAT(Prefix, Suffix) @@ -79,6 +87,9 @@ struct all_true static const bool value = B0 && all_true::value; }; +template +struct types; + // // based on Walter Brown's void_t proposal // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3911.pdf -- GitLab From 8160e1a40216a8159120d933a2a3c077321d633a Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 2 Oct 2014 21:04:04 -0700 Subject: [PATCH 441/782] more warnings squashed --- Rx/v2/examples/pythagorian/main.cpp | 12 ++++++------ Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 4 ++++ Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 8 ++++++++ Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp | 6 ++++++ Rx/v2/src/rxcpp/operators/rx-window_time.hpp | 2 +- Rx/v2/src/rxcpp/rx-scheduler.hpp | 5 ++++- Rx/v2/src/rxcpp/rx-subscriber.hpp | 2 +- Rx/v2/src/rxcpp/rx-trace.hpp | 4 ++-- 10 files changed, 34 insertions(+), 13 deletions(-) diff --git a/Rx/v2/examples/pythagorian/main.cpp b/Rx/v2/examples/pythagorian/main.cpp index 379b1e2..309b16d 100644 --- a/Rx/v2/examples/pythagorian/main.cpp +++ b/Rx/v2/examples/pythagorian/main.cpp @@ -39,7 +39,7 @@ struct trace_calls : rxcpp::trace_noop } template - inline void subscribe_return(const Observable& o) { + inline void subscribe_return(const Observable&) { subscribes++; } @@ -106,9 +106,9 @@ namespace rxu=rxcpp::util; // DO NOT USE: 'using namespace std;' #ifdef UNICODE -int wmain(int argc, wchar_t** argv) +int wmain() #else -int main(int argc, char** argv) +int main() #endif { int c = 0; @@ -125,16 +125,16 @@ int main(int argc, char** argv) .map([=](int y){return std::make_tuple(x, y, z);}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int x, std::tuple triplet){return triplet;}) + [](int /*x*/, std::tuple triplet){return triplet;}) // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic();}, - [](int z, std::tuple triplet){return triplet;}); + [](int /*z*/, std::tuple triplet){return triplet;}); int ct = 0; triples .take(100) - .subscribe(rxu::apply_to([&ct](int x,int y,int z){ + .subscribe(rxu::apply_to([&ct](int /*x*/,int /*y*/,int /*z*/){ ++ct; })); diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp index e3a2970..56507d4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp @@ -60,7 +60,7 @@ struct buffer_count for(auto& chunk : chunks) { chunk.push_back(v); } - while (!chunks.empty() && chunks.front().size() == this->count) { + while (!chunks.empty() && int(chunks.front().size()) == this->count) { dest.on_next(std::move(chunks.front())); chunks.pop_front(); } diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp index a14e854..dac1302 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -73,7 +73,7 @@ struct buffer_with_time : state(std::make_shared(buffer_with_time_subscriber_values(std::move(d), v, std::move(c)))) { auto localState = state; - auto produce_buffer = [localState](const rxsc::schedulable& self) { + auto produce_buffer = [localState](const rxsc::schedulable&) { localState->dest.on_next(std::move(localState->chunks.front())); localState->chunks.pop_front(); }; diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 98cec31..a8be1a7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -79,6 +79,8 @@ struct concat_map collection_selector_type selectCollection; result_selector_type selectResult; coordination_type coordination; + private: + values& operator=(const values&) RXCPP_DELETE; }; values initial; @@ -232,6 +234,8 @@ struct concat_map source->subscribe(std::move(selectedSink.get())); } +private: + concat_map& operator=(const concat_map&) RXCPP_DELETE; }; template diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 1c721e4..9d3d39b 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -94,6 +94,9 @@ struct reduce : public operator_base source; seed_type current; Subscriber out; + + private: + reduce_state_type& operator=(reduce_state_type o) RXCPP_DELETE; }; auto state = std::make_shared(initial, std::move(o)); state->source.subscribe( @@ -151,6 +157,8 @@ struct reduce : public operator_base diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp index e62e8ff..c1adb2c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp @@ -31,6 +31,8 @@ struct subscribe_on : public operator_base } source_type source; coordination_type coordination; + private: + subscribe_on_values& operator=(subscribe_on_values o) RXCPP_DELETE; }; const subscribe_on_values initial; @@ -59,6 +61,8 @@ struct subscribe_on : public operator_base composite_subscription source_lifetime; coordinator_type coordinator; output_type out; + private: + subscribe_on_state_type& operator=(subscribe_on_state_type o) RXCPP_DELETE; }; auto coordinator = initial.coordination.create_coordinator(s.get_subscription()); @@ -99,6 +103,8 @@ struct subscribe_on : public operator_base controller.schedule(selectedProducer.get()); } +private: + subscribe_on& operator=(subscribe_on o) RXCPP_DELETE; }; template diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp index aa01caa..aca16de 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -71,7 +71,7 @@ struct window_with_time : state(std::make_shared(window_with_time_subscriber_values(std::move(d), v, std::move(c)))) { auto localState = state; - auto release_window = [localState](const rxsc::schedulable& self) { + auto release_window = [localState](const rxsc::schedulable&) { localState->subj[0].get_subscriber().on_completed(); localState->subj.pop_front(); }; diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index df5f681..f91e66c 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -38,6 +38,7 @@ typedef std::shared_ptr const_scheduler_interface_ptr class recursed { bool& isrequested; + recursed operator=(const recursed&); public: explicit recursed(bool& r) : isrequested(r) @@ -56,6 +57,7 @@ class recurse bool& isallowed; mutable bool isrequested; recursed requestor; + recurse operator=(const recurse&); public: explicit recurse(bool& a) : isallowed(a) @@ -86,6 +88,7 @@ class recursion { mutable bool isallowed; recurse recursor; + recursion operator=(const recursion&); public: recursion() : isallowed(true) @@ -433,7 +436,7 @@ class schedulable : public schedulable_base { // does not aquire recursion scope } - recursed_scope_type& operator=(const recursed_scope_type& o) + recursed_scope_type& operator=(const recursed_scope_type& ) { // no change in recursion scope return *this; diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 39e6bdc..2e2661d 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -679,7 +679,7 @@ auto make_subscriber(const subscriber& scbr, trace_id id, } template -auto make_subscriber(const subscriber& scbr, const composite_subscription& cs, +auto make_subscriber(const subscriber& , const composite_subscription& cs, const observer& o) -> subscriber> { return subscriber>(trace_id::make_next_id_subscriber(), cs, o); diff --git a/Rx/v2/src/rxcpp/rx-trace.hpp b/Rx/v2/src/rxcpp/rx-trace.hpp index e72caaf..a148953 100644 --- a/Rx/v2/src/rxcpp/rx-trace.hpp +++ b/Rx/v2/src/rxcpp/rx-trace.hpp @@ -58,9 +58,9 @@ struct trace_noop inline void action_recurse(const Schedulable&) {} template - inline void subscribe_enter(const Observable& o, const Subscriber& s) {} + inline void subscribe_enter(const Observable& , const Subscriber& ) {} template - inline void subscribe_return(const Observable& o) {} + inline void subscribe_return(const Observable& ) {} template inline void connect(const SubscriberFrom&, const SubscriberTo&) {} -- GitLab From 00766799d6950706167af26fe2e344f744b509ab Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 2 Oct 2014 21:06:29 -0700 Subject: [PATCH 442/782] increases warning level, fixes warnings temporarily removes combine_latest probably breaks clang and gcc compilation both must be fixed before pushing to master --- Rx/v2/src/rxcpp/rx-observable.hpp | 47 +++++++++++++++----------- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 12 +++---- projects/CMake/CMakeLists.txt | 19 ++++++----- 3 files changed, 45 insertions(+), 33 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 1561c8e..10836ff 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -341,7 +341,7 @@ private: if (rxsc::current_thread::is_schedule_required()) { const auto& sc = rxsc::make_current_thread(); sc.create_worker(o.get_subscription()).schedule( - [&](const rxsc::schedulable& scbl) { + [&](const rxsc::schedulable&) { safe_subscribe(); }); } else { @@ -820,14 +820,23 @@ public: rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } +#if 0 + template + struct defer_combine_latest : public defer_observable{}; +#if 0 template - struct defer_combine_latest : public defer_observable< - rxu::all_true::value, !is_coordination::value, !is_observable::value, is_observable::value...>, - this_type, - rxo::detail::combine_latest, Coordination, Selector, ObservableN...> + struct defer_combine_latest< + Coordination, + Selector, + rxu::types, + typename rxu::types_checked_from::type> : + public defer_observable< + rxu::all_true::value, !is_coordination::value, !is_observable::value, is_observable::value...>, + this_type, + rxo::detail::combine_latest, Coordination, Selector, ObservableN...> { }; - +#endif /// combine_latest -> /// All sources must be synchronized! This means that calls across all the subscribers must be serial. /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. @@ -835,9 +844,9 @@ public: template auto combine_latest(Selector&& s, ObservableN... on) const -> typename std::enable_if< - defer_combine_latest::value, - typename defer_combine_latest::observable_type>::type { - return defer_combine_latest::make(*this, identity_current_thread(), std::forward(s), std::make_tuple(*this, on...)); + defer_combine_latest>::value, + typename defer_combine_latest>::observable_type>::type { + return defer_combine_latest>::make(*this, identity_current_thread(), std::forward(s), std::make_tuple(*this, on...)); } /// combine_latest -> @@ -847,9 +856,9 @@ public: template auto combine_latest(Coordination cn, Selector&& s, ObservableN... on) const -> typename std::enable_if< - defer_combine_latest::value, - typename defer_combine_latest::observable_type>::type { - return defer_combine_latest::make(*this, std::move(cn), std::forward(s), std::make_tuple(*this, on...)); + defer_combine_latest>::value, + typename defer_combine_latest>::observable_type>::type { + return defer_combine_latest>::make(*this, std::move(cn), std::forward(s), std::make_tuple(*this, on...)); } /// combine_latest -> @@ -859,9 +868,9 @@ public: template auto combine_latest(ObservableN... on) const -> typename std::enable_if< - defer_combine_latest::value, - typename defer_combine_latest::observable_type>::type { - return defer_combine_latest::make(*this, identity_current_thread(), rxu::pack(), std::make_tuple(*this, on...)); + defer_combine_latest>::value, + typename defer_combine_latest>::observable_type>::type { + return defer_combine_latest>::make(*this, identity_current_thread(), rxu::pack(), std::make_tuple(*this, on...)); } /// combine_latest -> @@ -871,11 +880,11 @@ public: template auto combine_latest(Coordination cn, ObservableN... on) const -> typename std::enable_if< - defer_combine_latest::value, - typename defer_combine_latest::observable_type>::type { - return defer_combine_latest::make(*this, std::move(cn), rxu::pack(), std::make_tuple(*this, on...)); + defer_combine_latest>::value, + typename defer_combine_latest>::observable_type>::type { + return defer_combine_latest>::make(*this, std::move(cn), rxu::pack(), std::make_tuple(*this, on...)); } - +#endif /// group_by -> /// template diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index ec77c40..331bea9 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -174,7 +174,7 @@ public: abort(); } virtual std::vector subscriptions() const { - abort(); return std::vector(); + abort(); } virtual std::vector messages() const { @@ -247,7 +247,7 @@ public: auto n = message.value(); sc->schedule_relative(message.time(), make_schedulable( controller, - [n, o](const schedulable& scbl) { + [n, o](const schedulable&) { if (o.is_subscribed()) { n->accept(o); } @@ -300,7 +300,7 @@ public: auto n = message.value(); sc->schedule_absolute(message.time(), make_schedulable( controller, - [this, n](const schedulable& scbl) { + [this, n](const schedulable&) { auto local = this->observers; for (auto& o : local) { if (o.is_subscribed()) { @@ -471,13 +471,13 @@ public: }; std::shared_ptr state(new state_type(this->make_subscriber())); - schedule_absolute(created, [createSource, state](const schedulable& scbl) { + schedule_absolute(created, [createSource, state](const schedulable&) { state->source.reset(new typename state_type::source_type(createSource())); }); - schedule_absolute(subscribed, [state](const schedulable& scbl) { + schedule_absolute(subscribed, [state](const schedulable&) { state->source->subscribe(state->o); }); - schedule_absolute(unsubscribed, [state](const schedulable& scbl) { + schedule_absolute(unsubscribed, [state](const schedulable&) { state->o.unsubscribe(); }); diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index ae8dd39..b94247c 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -7,11 +7,16 @@ MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) FIND_PACKAGE(Threads) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - list( APPEND CMAKE_CXX_FLAGS " -std=c++11 -ftemplate-depth=1024 ${CMAKE_CXX_FLAGS}") + add_compile_options( -Wall -Wextra -Werror ) + add_compile_options( -std=c++11 ) + add_compile_options( -ftemplate-depth=1024 ) # sometimes you just do what the compiler tells you elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - list( APPEND CMAKE_CXX_FLAGS " -std=c++11 ${CMAKE_CXX_FLAGS}") + add_compile_options( -Wall -Wextra -Werror ) + add_compile_options( -std=c++11 ) elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - list( APPEND CMAKE_CXX_FLAGS " /DUNICODE /D_UNICODE /bigobj ${CMAKE_CXX_FLAGS}") + add_compile_options( /W4 /WX ) + add_compile_options( /wd4503 ) # truncated symbol + add_definitions( /DUNICODE /D_UNICODE ) # it is a new millenium endif() @@ -21,10 +26,8 @@ get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) MESSAGE( STATUS "RXCPP_DIR: " ${RXCPP_DIR} ) - include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) - set(TEST_DIR ${RXCPP_DIR}/Rx/v2/test) # define the sources of the self test @@ -38,8 +41,8 @@ set(TEST_SOURCES ${TEST_DIR}/sources/interval.cpp ${TEST_DIR}/sources/scope.cpp ${TEST_DIR}/operators/buffer.cpp - ${TEST_DIR}/operators/combine_latest.1.cpp - ${TEST_DIR}/operators/combine_latest.2.cpp + #${TEST_DIR}/operators/combine_latest.1.cpp + #${TEST_DIR}/operators/combine_latest.2.cpp ${TEST_DIR}/operators/concat.cpp ${TEST_DIR}/operators/concat_map.cpp ${TEST_DIR}/operators/distinct_until_changed.cpp @@ -69,7 +72,7 @@ TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) # define the sources of the self test set(ONE_SOURCES ${TEST_DIR}/test.cpp -# ${TEST_DIR}/operators/subscribe_on.cpp + ${TEST_DIR}/operators/buffer.cpp ) add_executable(one_test ${ONE_SOURCES}) TARGET_LINK_LIBRARIES(one_test ${CMAKE_THREAD_LIBS_INIT}) -- GitLab From 0768cbf4aa5706b7b91e54cfc6c764aaacd57ce7 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Thu, 2 Oct 2014 22:24:31 -0700 Subject: [PATCH 443/782] fix clang warnings --- Rx/v2/examples/println/main.cpp | 4 ++-- Rx/v2/src/rxcpp/rx-notification.hpp | 2 +- Rx/v2/src/rxcpp/rx-observable.hpp | 2 +- Rx/v2/src/rxcpp/rx-subscriber.hpp | 4 ++-- Rx/v2/src/rxcpp/rx-util.hpp | 1 + Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 4 ++-- Rx/v2/src/rxcpp/sources/rx-never.hpp | 2 +- Rx/v2/test/operators/buffer.cpp | 10 +++++----- Rx/v2/test/sources/scope.cpp | 4 ++-- Rx/v2/test/subscriptions/subscription.cpp | 4 ++-- 10 files changed, 19 insertions(+), 18 deletions(-) diff --git a/Rx/v2/examples/println/main.cpp b/Rx/v2/examples/println/main.cpp index b9cf842..e41a8c3 100644 --- a/Rx/v2/examples/println/main.cpp +++ b/Rx/v2/examples/println/main.cpp @@ -40,9 +40,9 @@ auto println(OStream& os) #endif #ifdef UNICODE -int wmain(int argc, wchar_t** argv) +int wmain() #else -int main(int argc, char** argv) +int main() #endif { auto get_names = [](){return rx::observable<>::from( diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index 064851a..0ba09ea 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -100,7 +100,7 @@ auto equals(const T& lhs, const T& rhs, int) } template -bool equals(const T& lhs, const T& rhs, ...) { +bool equals(const T&, const T&, ...) { throw std::runtime_error("value does not support equality tests"); return false; } diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 10836ff..6b1ba3e 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -450,7 +450,7 @@ public: /// into the expression. /// template - auto lift_if(Operator&& op) const + auto lift_if(Operator&&) const -> typename std::enable_if, Operator>::value, decltype(rxs::from())>::type { return rxs::from(); diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 2e2661d..0092637 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -112,7 +112,7 @@ public: const subscriber& o, typename std::enable_if< !std::is_same>::value && - std::is_same>::value, void**>::type select = nullptr) + std::is_same>::value, void**>::type = nullptr) : lifetime(o.lifetime) , destination(o.destination.as_dynamic()) , id(o.id) @@ -685,7 +685,7 @@ auto make_subscriber(const subscriber& , const composite_ return subscriber>(trace_id::make_next_id_subscriber(), cs, o); } template -auto make_subscriber(const subscriber& scbr, trace_id id, const composite_subscription& cs, +auto make_subscriber(const subscriber&, trace_id id, const composite_subscription& cs, const observer& o) -> subscriber> { return subscriber>(std::move(id), cs, o); diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index b6de101..2a6dae0 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -316,6 +316,7 @@ struct print_function template void operator()(const TN&... tn) const { bool inserts[] = {(os << tn, true)...}; + inserts[0] = *(inserts); // silence warning delimit(); } diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index 19aa84e..c78d0a2 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -160,14 +160,14 @@ template auto from(Value0 v0, ValueN... vn) -> typename std::enable_if::value, decltype(iterate(*(std::array*)nullptr, identity_immediate()))>::type { - std::array c = {v0, vn...}; + std::array c{{v0, vn...}}; return iterate(std::move(c), identity_immediate()); } template auto from(Coordination cn, Value0 v0, ValueN... vn) -> typename std::enable_if::value, decltype(iterate(*(std::array*)nullptr, std::move(cn)))>::type { - std::array c = {v0, vn...}; + std::array c{{v0, vn...}}; return iterate(std::move(c), std::move(cn)); } diff --git a/Rx/v2/src/rxcpp/sources/rx-never.hpp b/Rx/v2/src/rxcpp/sources/rx-never.hpp index 22b6c24..bcb991e 100644 --- a/Rx/v2/src/rxcpp/sources/rx-never.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-never.hpp @@ -17,7 +17,7 @@ template struct never : public source_base { template - void on_subscribe(Subscriber o) const { + void on_subscribe(Subscriber) const { } }; diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index eb71572..c8ade17 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -490,7 +490,7 @@ SCENARIO("buffer with time on intervals", "[buffer_with_time][operators][long][h }); printf("\n"); }, - [](std::exception_ptr e){ + [](std::exception_ptr){ printf("on_error\n"); }, [](){ @@ -534,7 +534,7 @@ SCENARIO("buffer with time on intervals, implicit coordination", "[buffer_with_t }); printf("\n"); }, - [](std::exception_ptr e){ + [](std::exception_ptr){ printf("on_error\n"); }, [](){ @@ -579,7 +579,7 @@ SCENARIO("buffer with time on overlapping intervals", "[buffer_with_time][operat }); printf("\n"); }, - [](std::exception_ptr e){ + [](std::exception_ptr){ printf("on_error\n"); }, [](){ @@ -624,7 +624,7 @@ SCENARIO("buffer with time on overlapping intervals, implicit coordination", "[b }); printf("\n"); }, - [](std::exception_ptr e){ + [](std::exception_ptr){ printf("on_error\n"); }, [](){ @@ -672,7 +672,7 @@ SCENARIO("buffer with time on intervals, error", "[buffer_with_time][operators][ }); printf("\n"); }, - [](std::exception_ptr e){ + [](std::exception_ptr){ printf("on_error\n"); }, [](){ diff --git a/Rx/v2/test/sources/scope.cpp b/Rx/v2/test/sources/scope.cpp index ac3fc16..476d434 100644 --- a/Rx/v2/test/sources/scope.cpp +++ b/Rx/v2/test/sources/scope.cpp @@ -348,7 +348,7 @@ SCENARIO("scope, throw resource selector", "[scope][sources]"){ throw ex; //return resource(sc.clock()); }, - [&](resource r){ + [&](resource){ ++observable_factory_invoked; return rx::observable<>::never(); } @@ -400,7 +400,7 @@ SCENARIO("scope, throw resource usage", "[scope][sources]"){ ++resource_factory_invoked; return resource(sc.clock()); }, - [&](resource r) -> rx::observable { + [&](resource) -> rx::observable { ++observable_factory_invoked; throw ex; } diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index 37c3683..ec4557f 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -124,7 +124,7 @@ SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug ++std::get<1>(*completionstate); std::get<2>(*completionstate).on_next(n); }, - [=](std::exception_ptr e){ + [=](std::exception_ptr){ abort(); }, [=](){ @@ -233,7 +233,7 @@ SCENARIO("observe_on range debug", "[hide][subscribe][range][observe_on_debug][o ++std::get<1>(*completionstate); std::get<2>(*completionstate).on_next(n); }, - [=](std::exception_ptr e){ + [=](std::exception_ptr){ abort(); }, [=](){ -- GitLab From 744ca46f8e050dffac77e285e1bbe8b9d4322153 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 3 Oct 2014 07:34:09 -0700 Subject: [PATCH 444/782] gcc warning fixes --- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 2 -- Rx/v2/src/rxcpp/sources/rx-range.hpp | 2 -- Rx/v2/test/operators/buffer.cpp | 5 ----- Rx/v2/test/sources/interval.cpp | 2 -- projects/CMake/CMakeLists.txt | 3 ++- projects/scripts/travis-install.sh | 1 + 6 files changed, 3 insertions(+), 12 deletions(-) diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index 0bb62f5..dade61a 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -43,8 +43,6 @@ struct interval : public source_base void on_subscribe(Subscriber o) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef typename coordinator_type::template get::type output_type; - // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index ec7ddf5..4af7c24 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -42,8 +42,6 @@ struct range : public source_base void on_subscribe(Subscriber o) const { static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); - typedef Subscriber output_type; - // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index c8ade17..b3103ea 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -469,7 +469,6 @@ SCENARIO("buffer with time on intervals", "[buffer_with_time][operators][long][h // 5-6 // -7 using namespace std::chrono; - typedef steady_clock clock; #define TIME milliseconds #define UNIT *15 @@ -513,7 +512,6 @@ SCENARIO("buffer with time on intervals, implicit coordination", "[buffer_with_t // 5-6 // -7 using namespace std::chrono; - typedef steady_clock clock; #define TIME milliseconds #define UNIT *15 @@ -558,7 +556,6 @@ SCENARIO("buffer with time on overlapping intervals", "[buffer_with_time][operat // 4-5 // 5 using namespace std::chrono; - typedef steady_clock clock; #define TIME milliseconds #define UNIT *15 @@ -603,7 +600,6 @@ SCENARIO("buffer with time on overlapping intervals, implicit coordination", "[b // 4-5 // 5 using namespace std::chrono; - typedef steady_clock clock; #define TIME milliseconds #define UNIT *15 @@ -648,7 +644,6 @@ SCENARIO("buffer with time on intervals, error", "[buffer_with_time][operators][ // 4-5 // 5 using namespace std::chrono; - typedef steady_clock clock; #define TIME milliseconds #define UNIT *15 diff --git a/Rx/v2/test/sources/interval.cpp b/Rx/v2/test/sources/interval.cpp index ae1a149..6ea3aeb 100644 --- a/Rx/v2/test/sources/interval.cpp +++ b/Rx/v2/test/sources/interval.cpp @@ -11,7 +11,6 @@ SCENARIO("schedule_periodically", "[hide][periodically][scheduler][long][perf][s GIVEN("schedule_periodically"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; - typedef steady_clock clock; int c = 0; auto sc = rxsc::make_current_thread(); @@ -76,7 +75,6 @@ SCENARIO("intervals", "[hide][periodically][interval][scheduler][long][perf][sou GIVEN("10 intervals of 1 seconds"){ WHEN("the period is 1sec and the initial is 2sec"){ using namespace std::chrono; - typedef steady_clock clock; int c = 0; auto sc = rxsc::make_current_thread(); diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index b94247c..4665cea 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -26,7 +26,8 @@ get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) MESSAGE( STATUS "RXCPP_DIR: " ${RXCPP_DIR} ) -include_directories(${RXCPP_DIR}/ext/catch/include ${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) +include_directories(SYSTEM ${RXCPP_DIR}/ext/catch/include) +include_directories(${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) set(TEST_DIR ${RXCPP_DIR}/Rx/v2/test) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 2cfcd39..ef64661 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -6,6 +6,7 @@ set -e if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key|sudo apt-key add - sudo add-apt-repository -y 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise main' + sudo add-apt-repository -y "deb http://us.archive.ubuntu.com/ubuntu/ trusty main universe" sudo add-apt-repository -y ppa:28msec/utils # Recent cmake sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang-3.5 sudo apt-get clean -qq || echo "ignore clean failure" -- GitLab From bcddb5e06675292fe313c2b5b51102e341955583 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Fri, 3 Oct 2014 15:10:22 -0700 Subject: [PATCH 445/782] re-enable combine_latest not pleased with the resulting code in observable. I want concepts :) --- .../src/rxcpp/operators/rx-combine_latest.hpp | 2 +- Rx/v2/src/rxcpp/rx-observable.hpp | 131 ++++++++++-------- Rx/v2/src/rxcpp/rx-util.hpp | 6 + Rx/v2/test/operators/combine_latest.2.cpp | 4 +- Rx/v2/test/subscriptions/subscription.cpp | 4 +- projects/CMake/CMakeLists.txt | 7 +- 6 files changed, 89 insertions(+), 65 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index 9a0b057..3128217 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -15,7 +15,6 @@ namespace detail { template struct combine_latest_traits { - static_assert(rxu::all_true::value...>::value, "combine_latest requires observables"); typedef std::tuple tuple_source_type; typedef std::tuple...> tuple_source_value_type; @@ -137,6 +136,7 @@ struct combine_latest : public operator_base void subscribe_all(std::shared_ptr state, rxu::values) const { bool subscribed[] = {(subscribe_one(state), true)...}; + subscribed[0] = (*subscribed); // silence warning } template diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 6b1ba3e..fc724b9 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -820,71 +820,90 @@ public: rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } -#if 0 - template - struct defer_combine_latest : public defer_observable{}; -#if 0 - template - struct defer_combine_latest< - Coordination, - Selector, - rxu::types, - typename rxu::types_checked_from::type> : - public defer_observable< - rxu::all_true::value, !is_coordination::value, !is_observable::value, is_observable::value...>, - this_type, - rxo::detail::combine_latest, Coordination, Selector, ObservableN...> + template + struct select_combine_latest_cn : public std::false_type {}; + + template + struct select_combine_latest_cn, typename rxu::types_checked_from::type> + : public std::true_type { + typedef rxo::detail::combine_latest operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, Coordination cn, ObservableN... on) const { + return observable_type(operator_type(std::move(cn), rxu::pack(), std::make_tuple(src, std::move(on)...))); + }; }; -#endif - /// combine_latest -> - /// All sources must be synchronized! This means that calls across all the subscribers must be serial. - /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. - /// - template - auto combine_latest(Selector&& s, ObservableN... on) const - -> typename std::enable_if< - defer_combine_latest>::value, - typename defer_combine_latest>::observable_type>::type { - return defer_combine_latest>::make(*this, identity_current_thread(), std::forward(s), std::make_tuple(*this, on...)); - } - /// combine_latest -> - /// The coordination is used to synchronize sources from different contexts. - /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. - /// - template - auto combine_latest(Coordination cn, Selector&& s, ObservableN... on) const - -> typename std::enable_if< - defer_combine_latest>::value, - typename defer_combine_latest>::observable_type>::type { - return defer_combine_latest>::make(*this, std::move(cn), std::forward(s), std::make_tuple(*this, on...)); - } + template + struct select_combine_latest_cn, typename rxu::types_checked_from::type, typename Coordination::coordination_tag, typename TN::observable_tag...>::type> + : public std::true_type + { + typedef rxo::detail::combine_latest operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, Coordination cn, T0 t0, ObservableN... on) const { + return observable_type(operator_type(std::move(cn), std::move(t0), std::make_tuple(src, std::move(on)...))); + }; + }; - /// combine_latest -> - /// All sources must be synchronized! This means that calls across all the subscribers must be serial. - /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. - /// - template - auto combine_latest(ObservableN... on) const - -> typename std::enable_if< - defer_combine_latest>::value, - typename defer_combine_latest>::observable_type>::type { - return defer_combine_latest>::make(*this, identity_current_thread(), rxu::pack(), std::make_tuple(*this, on...)); - } + template + struct select_combine_latest : public std::false_type { + template + void operator()(const Source&, T0, T1, TN...) const { + static_assert(is_coordination::value || + is_observable::value || + std::is_convertible>::value + , "T0 must be selector, coordination or observable"); + static_assert(is_observable::value || + std::is_convertible>::value, "T1 must be selector or observable"); + static_assert(rxu::all_true::value...>::value, "TN... must be observable"); + } + template + void operator()(const Source&, T0) const { + static_assert(is_observable::value, "T0 must be observable"); + } + }; + + template + struct select_combine_latest, typename rxu::types_checked_from::type> + : public select_combine_latest_cn> + { + }; + + template + struct select_combine_latest, typename rxu::types_checked_from::type, typename TN::observable_tag...>::type> + : public std::true_type + { + typedef rxo::detail::combine_latest operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, Selector sel, ObservableN... on) const { + return observable_type(operator_type(identity_current_thread(), std::move(sel), std::make_tuple(src, std::move(on)...))); + }; + }; + + template + struct select_combine_latest, typename rxu::types_checked_from::type> + : public std::true_type + { + typedef rxo::detail::combine_latest operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, ObservableN... on) const { + return observable_type(operator_type(identity_current_thread(), rxu::pack(), std::make_tuple(src, std::move(on)...))); + }; + }; /// combine_latest -> - /// The coordination is used to synchronize sources from different contexts. /// for each item from all of the observables use the Selector to select a value to emit from the new observable that is returned. /// - template - auto combine_latest(Coordination cn, ObservableN... on) const - -> typename std::enable_if< - defer_combine_latest>::value, - typename defer_combine_latest>::observable_type>::type { - return defer_combine_latest>::make(*this, std::move(cn), rxu::pack(), std::make_tuple(*this, on...)); + template + auto combine_latest(AN... an) const + -> decltype(select_combine_latest>{}(*(this_type*)nullptr, std::move(an)...)) { + return select_combine_latest>{}(*this, std::move(an)...); } -#endif + /// group_by -> /// template diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 2a6dae0..94bbadf 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -334,6 +334,8 @@ struct endline void operator()() const { os << std::endl; } +private: + endline& operator=(const endline&) RXCPP_DELETE; }; template @@ -345,6 +347,8 @@ struct insert_value void operator()() const { os << value; } +private: + insert_value& operator=(const insert_value&) RXCPP_DELETE; }; template @@ -356,6 +360,8 @@ struct insert_function void operator()() const { call(os); } +private: + insert_function& operator=(const insert_function&) RXCPP_DELETE; }; template diff --git a/Rx/v2/test/operators/combine_latest.2.cpp b/Rx/v2/test/operators/combine_latest.2.cpp index 7406a26..de7167a 100644 --- a/Rx/v2/test/operators/combine_latest.2.cpp +++ b/Rx/v2/test/operators/combine_latest.2.cpp @@ -771,7 +771,7 @@ SCENARIO("combine_latest selector throws", "[combine_latest][join][operators]"){ [&]() { return o1 .combine_latest( - [&ex](int v2, int v1) -> int { + [&ex](int, int) -> int { throw ex; }, o2 @@ -834,7 +834,7 @@ SCENARIO("combine_latest selector throws N", "[combine_latest][join][operators]" [&]() { return e[0] .combine_latest( - [&ex](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15) -> int { + [&ex](int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int) -> int { throw ex; }, e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] diff --git a/Rx/v2/test/subscriptions/subscription.cpp b/Rx/v2/test/subscriptions/subscription.cpp index ec4557f..f60cded 100644 --- a/Rx/v2/test/subscriptions/subscription.cpp +++ b/Rx/v2/test/subscriptions/subscription.cpp @@ -52,7 +52,6 @@ SCENARIO("for loop subscribes to map", "[hide][for][just][subscribe][long][perf] } } -#if 0 SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_latest][subscribe][long][perf]"){ const int& subscriptions = static_subscriptions; GIVEN("a for loop"){ @@ -73,7 +72,7 @@ SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_lat .combine_latest([](int i, int j) { return i + j; }, rx::observable<>::just(2)) - .subscribe([&](int i){ + .subscribe([&](int){ ++c; }); } @@ -90,7 +89,6 @@ SCENARIO("for loop subscribes to combine_latest", "[hide][for][just][combine_lat } } } -#endif SCENARIO("synchronized range debug", "[hide][subscribe][range][synchronize_debug][synchronize][long][perf]"){ GIVEN("range"){ diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index 4665cea..a065376 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -42,8 +42,8 @@ set(TEST_SOURCES ${TEST_DIR}/sources/interval.cpp ${TEST_DIR}/sources/scope.cpp ${TEST_DIR}/operators/buffer.cpp - #${TEST_DIR}/operators/combine_latest.1.cpp - #${TEST_DIR}/operators/combine_latest.2.cpp + ${TEST_DIR}/operators/combine_latest.1.cpp + ${TEST_DIR}/operators/combine_latest.2.cpp ${TEST_DIR}/operators/concat.cpp ${TEST_DIR}/operators/concat_map.cpp ${TEST_DIR}/operators/distinct_until_changed.cpp @@ -73,7 +73,8 @@ TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) # define the sources of the self test set(ONE_SOURCES ${TEST_DIR}/test.cpp - ${TEST_DIR}/operators/buffer.cpp + #${TEST_DIR}/operators/combine_latest.1.cpp + #${TEST_DIR}/operators/combine_latest.2.cpp ) add_executable(one_test ${ONE_SOURCES}) TARGET_LINK_LIBRARIES(one_test ${CMAKE_THREAD_LIBS_INIT}) -- GitLab From 41b74f99c254bc12ea2aa0da4c242c99aaaafc9d Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 6 Oct 2014 07:50:39 -0700 Subject: [PATCH 446/782] clang warning clean --- Rx/v2/src/rxcpp/rx-observable.hpp | 10 +++++----- Rx/v2/test/operators/combine_latest.1.cpp | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index fc724b9..8ca0d57 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -820,7 +820,7 @@ public: rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } - template + template struct select_combine_latest_cn : public std::false_type {}; template @@ -836,7 +836,7 @@ public: }; template - struct select_combine_latest_cn, typename rxu::types_checked_from::type, typename Coordination::coordination_tag, typename TN::observable_tag...>::type> + struct select_combine_latest_cn, typename rxu::types_checked_from::type, typename Coordination::coordination_tag, typename TN::observable_tag...>::type> : public std::true_type { typedef rxo::detail::combine_latest operator_type; @@ -847,7 +847,7 @@ public: }; }; - template + template struct select_combine_latest : public std::false_type { template void operator()(const Source&, T0, T1, TN...) const { @@ -857,7 +857,7 @@ public: , "T0 must be selector, coordination or observable"); static_assert(is_observable::value || std::is_convertible>::value, "T1 must be selector or observable"); - static_assert(rxu::all_true::value...>::value, "TN... must be observable"); + static_assert(rxu::all_true::value...>::value, "TN... must be observable"); } template void operator()(const Source&, T0) const { @@ -872,7 +872,7 @@ public: }; template - struct select_combine_latest, typename rxu::types_checked_from::type, typename TN::observable_tag...>::type> + struct select_combine_latest, typename rxu::types_checked_from::type, typename TN::observable_tag...>::type> : public std::true_type { typedef rxo::detail::combine_latest operator_type; diff --git a/Rx/v2/test/operators/combine_latest.1.cpp b/Rx/v2/test/operators/combine_latest.1.cpp index 0493c78..04d98b4 100644 --- a/Rx/v2/test/operators/combine_latest.1.cpp +++ b/Rx/v2/test/operators/combine_latest.1.cpp @@ -278,7 +278,7 @@ SCENARIO("combine_latest never N", "[combine_latest][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const size_t N = 16; + const int N = 16; std::vector> n; for (int i = 0; i < N; ++i) { @@ -331,7 +331,7 @@ SCENARIO("combine_latest empty N", "[combine_latest][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const size_t N = 16; + const int N = 16; std::vector> e; for (int i = 0; i < N; ++i) { -- GitLab From daa2e0452d9137376e40f9b823fd35d386ee745e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 6 Oct 2014 08:42:15 -0700 Subject: [PATCH 447/782] ctest is broken on linux --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 9fda0a0..bc9a026 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,7 +11,7 @@ compiler: env: - BUILD_TYPE=Release - + matrix: exclude: - compiler: gcc @@ -29,7 +29,7 @@ install: script: - cd projects/build - - ctest -V + - ./rxcppv2_test - cd ../.. branches: -- GitLab From f948ab5266bcdc5fd98d9536499fdd9798ca45ac Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 16 Oct 2014 12:43:02 +0400 Subject: [PATCH 448/782] Travis compiling is repaired: 1. Use GCC 4.8.1. Note: - 4.8.2 causes run time error. 2. Use Clang 3.5 + GCC 4.8.1 libraries. Notes: - Libs from 4.8.2 cause run time error; - Clang 3.6 is incompatible with 4.8.2 libs; - Travis used Clang 3.4 earlier: the old script did not work, it was just installing clang 3.6 and not selecting it. 3. Reduce number of compiling threads to 2 - Travis VMs sometimes go out of memory on 4 threads. --- .travis.yml | 3 ++- projects/scripts/travis-install.sh | 7 +++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index bc9a026..cb701d0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -21,10 +21,11 @@ before_install: - sh projects/scripts/travis-install.sh install: + - export PATH=/usr/bin:$PATH - cd projects - cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX - cd build - - make -j4 + - make -j2 - cd ../.. script: diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index ef64661..950e8e7 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -15,13 +15,12 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing cmake libssl-dev if [ "$CC" = clang ]; then - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.6 - sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.6 20 - sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.6 20 + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.5 + sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 fi if [ "$CC" = gcc ]; then - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing gcc-4.8 g++-4.8 + sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 gcc-4.8=4.8.1-2ubuntu1~12.04 g++-4.8=4.8.1-2ubuntu1~12.04 sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 fi -- GitLab From 84abdaf85035ce63c2390d03ae2d8e9ceca8a689 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 10 Nov 2014 07:51:01 -0800 Subject: [PATCH 449/782] #41 - scan on_subscribe should be const --- Rx/v2/src/rxcpp/operators/rx-scan.hpp | 2 +- Rx/v2/test/operators/scan.cpp | 16 ++++++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-scan.hpp b/Rx/v2/src/rxcpp/operators/rx-scan.hpp index 12c4b2f..1b45437 100644 --- a/Rx/v2/src/rxcpp/operators/rx-scan.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-scan.hpp @@ -45,7 +45,7 @@ struct scan : public operator_base::type> static_assert(std::is_convertible(0)), seed_type>::value, "scan Accumulator must be a function with the signature Seed(Seed, T)"); } template - void on_subscribe(Subscriber o) { + void on_subscribe(Subscriber o) const { struct scan_state_type : public scan_initial_type , public std::enable_shared_from_this diff --git a/Rx/v2/test/operators/scan.cpp b/Rx/v2/test/operators/scan.cpp index 9d60d11..0645c87 100644 --- a/Rx/v2/test/operators/scan.cpp +++ b/Rx/v2/test/operators/scan.cpp @@ -5,6 +5,22 @@ namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" #include "catch.hpp" +SCENARIO("scan: issue 41", "[scan][operators][issue][hide]"){ + GIVEN("map of scan of interval"){ + auto sc = rxsc::make_current_thread(); + auto so = rxcpp::synchronize_in_one_worker(sc); + auto start = sc.now() + std::chrono::seconds(2); + auto period = std::chrono::seconds(1); + + rxcpp::observable<>::interval(start, period, so) + .scan(0, [] (int a, int i) { return a + i; }) + .map([] (int i) { return i * i; }) + .take(10) + .subscribe([] (int i) { std::cout << i << std::endl; }); + + } +} + SCENARIO("scan: seed, never", "[scan][operators]"){ GIVEN("a test hot observable of ints"){ auto sc = rxsc::make_test(); -- GitLab From c257c0574795cd2ac5f7c67782e1b6048c715f7f Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 10 Nov 2014 08:43:25 -0800 Subject: [PATCH 450/782] #39 - race on function static causes AV This moves function statics to class statics. Side effect is that the event_loop threads are started even if they are not used. A future change might make event_loop thread creation lazy. --- Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp | 7 +++++-- Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp | 7 +++++-- Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 7 +++++-- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 8 ++++++-- Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp | 3 +-- 5 files changed, 22 insertions(+), 10 deletions(-) diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 3c7bb90..64ae60b 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -248,11 +248,14 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(std::move(cs), wi); } + const static scheduler instance; }; +//static +RXCPP_SELECT_ANY const scheduler current_thread::instance = make_scheduler(); + inline const scheduler& make_current_thread() { - static auto ct = make_scheduler(); - return ct; + return current_thread::instance; } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp index fc8deb7..b5adf5b 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp @@ -93,11 +93,14 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(cs, std::shared_ptr(new loop_worker(cs, loops[++count % loops.size()]))); } + const static scheduler instance; }; +//static +RXCPP_SELECT_ANY const scheduler event_loop::instance = make_scheduler(); + inline scheduler make_event_loop() { - static auto loop = make_scheduler(); - return loop; + return event_loop::instance; } inline scheduler make_event_loop(thread_factory tf) { return make_scheduler(tf); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp index 73592ec..c990837 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -70,11 +70,14 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(std::move(cs), wi); } + const static scheduler instance; }; +//static +RXCPP_SELECT_ANY const scheduler immediate::instance = make_scheduler(); + inline const scheduler& make_immediate() { - static auto i = make_scheduler(); - return i; + return immediate::instance; } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp index 4144053..4d60cb6 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -162,11 +162,15 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(cs, std::shared_ptr(new new_worker(cs, factory))); } + + const static scheduler instance; }; +//static +RXCPP_SELECT_ANY const scheduler new_thread::instance = make_scheduler(); + inline scheduler make_new_thread() { - static auto nt = make_scheduler(); - return nt; + return new_thread::instance; } inline scheduler make_new_thread(thread_factory tf) { return make_scheduler(tf); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp b/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp index 5b3ff4e..4bfbd0b 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-sameworker.hpp @@ -42,8 +42,7 @@ public: }; inline scheduler make_same_worker(rxsc::worker w) { - auto i = make_scheduler(std::move(w)); - return i; + return make_scheduler(std::move(w)); } } -- GitLab From 290b645e253303d703cb89865feadd3ccb65f524 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Mon, 10 Nov 2014 08:50:11 -0800 Subject: [PATCH 451/782] ignore apt errors --- projects/scripts/travis-install.sh | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 950e8e7..9216297 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -12,17 +12,17 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then sudo apt-get clean -qq || echo "ignore clean failure" sudo apt-get update -qq || echo "ignore update failure" - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing cmake libssl-dev + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing cmake libssl-dev || echo "ignore install failure" if [ "$CC" = clang ]; then - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.5 - sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.5 || echo "ignore install failure" + sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 || echo "ignore install failure" fi if [ "$CC" = gcc ]; then - sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 gcc-4.8=4.8.1-2ubuntu1~12.04 g++-4.8=4.8.1-2ubuntu1~12.04 - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 + sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 gcc-4.8=4.8.1-2ubuntu1~12.04 g++-4.8=4.8.1-2ubuntu1~12.04 || echo "ignore install failure" + sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 || echo "ignore update failure" + sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 || echo "ignore update failure" fi elif [ "$TRAVIS_OS_NAME" = osx ]; then -- GitLab From 37668c96a49e6f5082caa36a0581f1d6b565291b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 11 Nov 2014 17:56:08 -0800 Subject: [PATCH 452/782] fix travis and workaround for libstd++ bug --- .travis.yml | 2 +- Rx/v2/test/test.cpp | 9 +++++++++ ext/catch | 2 +- projects/scripts/travis-install.sh | 25 ++++++++++++++++++++----- 4 files changed, 31 insertions(+), 7 deletions(-) diff --git a/.travis.yml b/.travis.yml index cb701d0..c7f1c83 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,7 +30,7 @@ install: script: - cd projects/build - - ./rxcppv2_test + - ./rxcppv2_test --success -r compact - cd ../.. branches: diff --git a/Rx/v2/test/test.cpp b/Rx/v2/test/test.cpp index 0c7c351..8fe512e 100644 --- a/Rx/v2/test/test.cpp +++ b/Rx/v2/test/test.cpp @@ -1,2 +1,11 @@ +#include +#if (__GLIBCXX__ / 10000) == 2014 +namespace std { +inline bool uncaught_exception() noexcept(true) { + return current_exception() != nullptr; +} +} +#endif + #define CATCH_CONFIG_MAIN #include "catch.hpp" diff --git a/ext/catch b/ext/catch index 6880a0c..d4e5f18 160000 --- a/ext/catch +++ b/ext/catch @@ -1 +1 @@ -Subproject commit 6880a0c909778e9036b37ac4ddc601eee56b7b39 +Subproject commit d4e5f184369ce34592bb6f89e793bdb22d1d011a diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 9216297..c6f9458 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -15,14 +15,29 @@ if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing cmake libssl-dev || echo "ignore install failure" if [ "$CC" = clang ]; then - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.5 || echo "ignore install failure" - sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 || echo "ignore install failure" + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.6 || echo "ignore install failure" + + sudo update-alternatives --remove-all clang || echo "ignore remove failure" + sudo update-alternatives --remove-all clang++ || echo "ignore remove failure" + + sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.6 20 + sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.6 20 + + sudo update-alternatives --config clang + sudo update-alternatives --config clang++ fi if [ "$CC" = gcc ]; then - sudo apt-get install --allow-unauthenticated --force-yes --fix-missing libgomp1=4.8.1-2ubuntu1~12.04 libitm1=4.8.1-2ubuntu1~12.04 libatomic1=4.8.1-2ubuntu1~12.04 libasan0=4.8.1-2ubuntu1~12.04 libtsan0=4.8.1-2ubuntu1~12.04 libquadmath0=4.8.1-2ubuntu1~12.04 libstdc++6=4.8.1-2ubuntu1~12.04 gcc-4.8-base=4.8.1-2ubuntu1~12.04 libstdc++-4.8-dev=4.8.1-2ubuntu1~12.04 cpp-4.8=4.8.1-2ubuntu1~12.04 libgcc-4.8-dev=4.8.1-2ubuntu1~12.04 gcc-4.8=4.8.1-2ubuntu1~12.04 g++-4.8=4.8.1-2ubuntu1~12.04 || echo "ignore install failure" - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 || echo "ignore update failure" - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 || echo "ignore update failure" + sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing gcc-4.8 g++-4.8 || echo "ignore install failure" + + sudo update-alternatives --remove-all gcc || echo "ignore remove failure" + sudo update-alternatives --remove-all g++ || echo "ignore remove failure" + + sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 + sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 + + sudo update-alternatives --config gcc + sudo update-alternatives --config g++ fi elif [ "$TRAVIS_OS_NAME" = osx ]; then -- GitLab From f8e6ed64d858b48fa939f6a4f62ba20b8ec684e6 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 20 Oct 2014 17:52:35 +0400 Subject: [PATCH 453/782] Add zip operator including tests --- Rx/v2/src/rxcpp/operators/rx-zip.hpp | 220 +++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 84 +++ Rx/v2/src/rxcpp/rx-operators.hpp | 3 +- Rx/v2/src/rxcpp/rx-util.hpp | 56 ++ Rx/v2/test/operators/zip.1.cpp | 942 ++++++++++++++++++++++++++ Rx/v2/test/operators/zip.2.cpp | 949 +++++++++++++++++++++++++++ projects/CMake/CMakeLists.txt | 2 + 7 files changed, 2255 insertions(+), 1 deletion(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-zip.hpp create mode 100644 Rx/v2/test/operators/zip.1.cpp create mode 100644 Rx/v2/test/operators/zip.2.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-zip.hpp b/Rx/v2/src/rxcpp/operators/rx-zip.hpp new file mode 100644 index 0000000..d3c3ee7 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-zip.hpp @@ -0,0 +1,220 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_ZIP_HPP) +#define RXCPP_OPERATORS_RX_ZIP_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct zip_traits { + typedef std::tuple tuple_source_type; + typedef std::tuple...> tuple_source_values_type; + + typedef typename std::decay::type selector_type; + typedef typename std::decay::type coordination_type; + + struct tag_not_valid {}; + template + static auto check(int) -> decltype((*(CS*)nullptr)((*(CVN*)nullptr)...)); + template + static tag_not_valid check(...); + + static_assert(!std::is_same(0)), tag_not_valid>::value, "zip Selector must be a function with the signature value_type(Observable::value_type...)"); + + typedef decltype(check(0)) value_type; +}; + +template +struct zip : public operator_base::value_type> +{ + typedef zip this_type; + + typedef zip_traits traits; + + typedef typename traits::tuple_source_type tuple_source_type; + typedef typename traits::tuple_source_values_type tuple_source_values_type; + + typedef typename traits::selector_type selector_type; + + typedef typename traits::coordination_type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + + struct values + { + values(tuple_source_type o, selector_type s, coordination_type sf) + : source(std::move(o)) + , selector(std::move(s)) + , coordination(std::move(sf)) + { + } + tuple_source_type source; + selector_type selector; + coordination_type coordination; + }; + values initial; + + zip(coordination_type sf, selector_type s, tuple_source_type ts) + : initial(std::move(ts), std::move(s), std::move(sf)) + { + } + + template + void subscribe_one(std::shared_ptr state) const { + + typedef typename std::tuple_element::type::value_type source_value_type; + + composite_subscription innercs; + + // when the out observer is unsubscribed all the + // inner subscriptions are unsubscribed as well + state->out.add(innercs); + + auto source = on_exception( + [&](){return state->coordinator.in(std::get(state->source));}, + state->out); + if (source.empty()) { + return; + } + + // this subscribe does not share the observer subscription + // so that when it is unsubscribed the observer can be called + // until the inner subscriptions have finished + auto sink = make_subscriber( + state->out, + innercs, + // on_next + [state](source_value_type st) { + auto& values = std::get(state->pending); + values.push_back(st); + auto lne = rxu::list_not_empty(); + auto avt = rxu::all_values_true(); + if (rxu::apply_to_each(state->pending, lne, avt)) { + //if (rxu::apply_to_each(state->pending, rxu::list_not_empty(), rxu::all_values_true())) { + auto selectedResult = on_exception( + [&](){ + auto elf = rxu::extract_list_front(); + return rxu::apply_to_each(state->pending, elf, state->selector); + //return rxu::apply_to_each(state->pending, rxu::extract_list_front(), state->selector); + }, + state->out); + if (selectedResult.empty()) { + return; + } + state->out.on_next(selectedResult.get()); + } + }, + // on_error + [state](std::exception_ptr e) { + state->out.on_error(e); + }, + // on_completed + [state]() { + if (--state->pendingCompletions == 0) { + state->out.on_completed(); + } + } + ); + auto selectedSink = on_exception( + [&](){return state->coordinator.out(sink);}, + state->out); + if (selectedSink.empty()) { + return; + } + source->subscribe(std::move(selectedSink.get())); + } + template + void subscribe_all(std::shared_ptr state, rxu::values) const { + bool subscribed[] = {(subscribe_one(state), true)...}; + subscribed[0] = (*subscribed); // silence warning + } + + template + void on_subscribe(Subscriber scbr) const { + static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); + + typedef Subscriber output_type; + + struct zip_state_type + : public std::enable_shared_from_this + , public values + { + zip_state_type(values i, coordinator_type coor, output_type oarg) + : values(std::move(i)) + , pendingCompletions(sizeof... (ObservableN)) + , valuesSet(0) + , coordinator(std::move(coor)) + , out(std::move(oarg)) + { + } + + // on_completed on the output must wait until all the + // subscriptions have received on_completed + mutable int pendingCompletions; + mutable int valuesSet; + mutable tuple_source_values_type pending; + coordinator_type coordinator; + output_type out; + }; + + auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); + + // take a copy of the values for each subscription + auto state = std::shared_ptr(new zip_state_type(initial, std::move(coordinator), std::move(scbr))); + + subscribe_all(state, typename rxu::values_from::type()); + } +}; + +template +class zip_factory +{ + typedef typename std::decay::type coordination_type; + typedef typename std::decay::type selector_type; + typedef std::tuple tuple_source_type; + + coordination_type coordination; + selector_type selector; + tuple_source_type sourcen; + + template + auto make(std::tuple source) + -> observable::value_type, zip> { + return observable::value_type, zip>( + zip(coordination, selector, std::move(source))); + } +public: + zip_factory(coordination_type sf, selector_type s, ObservableN... on) + : coordination(std::move(sf)) + , selector(std::move(s)) + , sourcen(std::make_tuple(std::move(on)...)) + { + } + + template + auto operator()(Observable source) + -> decltype(make(std::tuple_cat(std::make_tuple(source), *(tuple_source_type*)nullptr))) { + return make(std::tuple_cat(std::make_tuple(source), sourcen)); + } +}; + +} + +template +auto zip(Coordination sf, Selector s, ObservableN... on) + -> detail::zip_factory { + return detail::zip_factory(std::move(sf), std::move(s), std::move(on)...); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 8ca0d57..61ada1a 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -904,6 +904,90 @@ public: return select_combine_latest>{}(*this, std::move(an)...); } + template + struct select_zip_cn : public std::false_type {}; + + template + struct select_zip_cn, typename rxu::types_checked_from::type> + : public std::true_type + { + typedef rxo::detail::zip operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, Coordination cn, ObservableN... on) const { + return observable_type(operator_type(std::move(cn), rxu::pack(), std::make_tuple(src, std::move(on)...))); + }; + }; + + template + struct select_zip_cn, typename rxu::types_checked_from::type, typename Coordination::coordination_tag, typename TN::observable_tag...>::type> + : public std::true_type + { + typedef rxo::detail::zip operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, Coordination cn, T0 t0, ObservableN... on) const { + return observable_type(operator_type(std::move(cn), std::move(t0), std::make_tuple(src, std::move(on)...))); + }; + }; + + template + struct select_zip : public std::false_type { + template + void operator()(const Source&, T0, T1, TN...) const { + static_assert(is_coordination::value || + is_observable::value || + std::is_convertible>::value + , "T0 must be selector, coordination or observable"); + static_assert(is_observable::value || + std::is_convertible>::value, "T1 must be selector or observable"); + static_assert(rxu::all_true::value...>::value, "TN... must be observable"); + } + template + void operator()(const Source&, T0) const { + static_assert(is_observable::value, "T0 must be observable"); + } + }; + + template + struct select_zip, typename rxu::types_checked_from::type> + : public select_zip_cn> + { + }; + + template + struct select_zip, typename rxu::types_checked_from::type, typename TN::observable_tag...>::type> + : public std::true_type + { + typedef rxo::detail::zip operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, Selector sel, ObservableN... on) const { + return observable_type(operator_type(identity_current_thread(), std::move(sel), std::make_tuple(src, std::move(on)...))); + }; + }; + + template + struct select_zip, typename rxu::types_checked_from::type> + : public std::true_type + { + typedef rxo::detail::zip operator_type; + typedef observable observable_type; + template + observable_type operator()(const Source& src, ObservableN... on) const { + return observable_type(operator_type(identity_current_thread(), rxu::pack(), std::make_tuple(src, std::move(on)...))); + }; + }; + + /// zip -> + /// bring by one item from all given observables and use the Selector to select a value to emit from the new observable that is returned. + /// + template + auto zip(AN... an) const + -> decltype(select_zip>{}(*(this_type*)nullptr, std::move(an)...)) { + return select_zip>{}(*this, std::move(an)...); + } + /// group_by -> /// template diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index b74d7a6..e9c4931 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -54,6 +54,7 @@ namespace rxo=operators; #include "operators/rx-reduce.hpp" #include "operators/rx-ref_count.hpp" #include "operators/rx-repeat.hpp" +#include "operators/rx-retry.hpp" #include "operators/rx-scan.hpp" #include "operators/rx-skip.hpp" #include "operators/rx-skip_until.hpp" @@ -65,5 +66,5 @@ namespace rxo=operators; #include "operators/rx-take_until.hpp" #include "operators/rx-window.hpp" #include "operators/rx-window_time.hpp" -#include "operators/rx-retry.hpp" +#include "operators/rx-zip.hpp" #endif diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 94bbadf..2f9868c 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -87,6 +87,21 @@ struct all_true static const bool value = B0 && all_true::value; }; +struct all_values_true { + template + bool operator()(ValueN... vn); + + template + bool operator()(Value0 v0) { + return v0; + } + + template + bool operator()(Value0 v0, ValueN... vn) { + return v0 && all_values_true()(vn...); + } +}; + template struct types; @@ -128,6 +143,18 @@ auto apply(std::tuple p, values, const F& f) return f(std::forward(std::get(p))...); } +template +auto apply_to_each(std::tuple& p, values, F_inner& f_inner, F_outer& f_outer) + -> decltype(f_outer(f_inner(std::get(p))...)) { + return f_outer(f_inner(std::get(p))...); +} + +template +auto apply_to_each(std::tuple& p, values, const F_inner& f_inner, const F_outer& f_outer) + -> decltype(f_outer(f_inner(std::forward(std::get(p)))...)) { + return f_outer(f_inner(std::forward(std::get(p)))...); +} + } template @@ -141,6 +168,18 @@ auto apply(std::tuple p, const F& f) return detail::apply(std::move(p), typename values_from::type(), f); } +template +auto apply_to_each(std::tuple& p, F_inner& f_inner, F_outer& f_outer) + -> decltype(detail::apply_to_each(p, typename values_from::type(), f_inner, f_outer)) { + return detail::apply_to_each(p, typename values_from::type(), f_inner, f_outer); +} + +template +auto apply_to_each(std::tuple& p, const F_inner& f_inner, const F_outer& f_outer) + -> decltype(detail::apply_to_each(p, typename values_from::type(), f_inner, f_outer)) { + return detail::apply_to_each(p, typename values_from::type(), f_inner, f_outer); +} + namespace detail { template @@ -546,6 +585,23 @@ inline auto surely(const std::tuple& tpl) return apply(tpl, detail::surely()); } +struct list_not_empty { + template + bool operator()(std::list& list) const { + return !list.empty(); + } +}; + +struct extract_list_front { + template + auto operator()(std::list& list) + -> decltype(std::move(list.front())) { + auto val = std::move(list.front()); + list.pop_front(); + return std::move(val); + } +}; + namespace detail { template diff --git a/Rx/v2/test/operators/zip.1.cpp b/Rx/v2/test/operators/zip.1.cpp new file mode 100644 index 0000000..5763177 --- /dev/null +++ b/Rx/v2/test/operators/zip.1.cpp @@ -0,0 +1,942 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("zip never/never", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n1 = sc.make_hot_observable({ + on.next(150, 1) + }); + + auto n2 = sc.make_hot_observable({ + on.next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n1 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + n2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip never N", "[zip][join][operators]"){ + GIVEN("N never completed hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const size_t N = 16; + + std::vector> n; + for (int i = 0; i < N; ++i) { + n.push_back( + sc.make_hot_observable({ + on.next(150, 1) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n[0] + .zip( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8], n[9], n[10], n[11], n[12], n[13], n[14], n[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(n.begin(), n.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("zip never/empty", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n = sc.make_hot_observable({ + on.next(150, 1) + }); + + auto e = sc.make_hot_observable({ + on.next(150, 1), + on.completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + e + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip empty/never", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e = sc.make_hot_observable({ + on.next(150, 1), + on.completed(210) + }); + + auto n = sc.make_hot_observable({ + on.next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip empty/empty", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e1 = sc.make_hot_observable({ + on.next(150, 1), + on.completed(210) + }); + + auto e2 = sc.make_hot_observable({ + on.next(150, 1), + on.completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e1 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + e2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.completed(210) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip empty N", "[zip][join][operators]"){ + GIVEN("N empty hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const size_t N = 16; + + std::vector> e; + for (int i = 0; i < N; ++i) { + e.push_back( + sc.make_hot_observable({ + on.next(150, 1), + on.completed(210 + 10 * i) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e[0] + .zip( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15){ + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.completed(200 + 10 * N) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + int i = 0; + std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 200 + 10 * ++i) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("zip empty/return", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto e = sc.make_hot_observable({ + on.next(150, 1), + on.completed(210) + }); + + auto o = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip return/empty", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.completed(220) + }); + + auto e = sc.make_hot_observable({ + on.next(150, 1), + on.completed(210) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + e + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only complete message"){ + auto required = rxu::to_vector({ + on.completed(220) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the e"){ + auto required = rxu::to_vector({ + on.subscribe(200, 210) + }); + auto actual = e.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip never/return", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto n = sc.make_hot_observable({ + on.next(150, 1) + }); + + auto o = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip return/never", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.completed(220) + }); + + auto n = sc.make_hot_observable({ + on.next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output is empty"){ + auto required = std::vector::recorded_type>(); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 1000) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip return/return", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(220, 3), + on.completed(240) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o1 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.next(220, 2 + 3), + on.completed(240) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 240) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip empty/error", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto emp = sc.make_hot_observable({ + on.next(150, 1), + on.completed(230) + }); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return emp + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the emp"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = emp.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error/empty", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + auto emp = sc.make_hot_observable({ + on.next(150, 1), + on.completed(230) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + emp + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the emp"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = emp.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip never/error", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto n = sc.make_hot_observable({ + on.next(150, 1) + }); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return n + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error/never", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + auto n = sc.make_hot_observable({ + on.next(150, 1) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + n + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the n"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = n.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error/error", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex1("zip on_error from source 1"); + std::runtime_error ex2("zip on_error from source 2"); + + auto err1 = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex1) + }); + + auto err2 = sc.make_hot_observable({ + on.next(150, 1), + on.error(230, ex2) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err1 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex1) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/Rx/v2/test/operators/zip.2.cpp b/Rx/v2/test/operators/zip.2.cpp new file mode 100644 index 0000000..d56cb83 --- /dev/null +++ b/Rx/v2/test/operators/zip.2.cpp @@ -0,0 +1,949 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("zip return/error", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto o = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.completed(230) + }); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error/return", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + auto ret = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.completed(230) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + ret + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = ret.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip left completes first", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.completed(220) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 4), + on.completed(225) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.next(215, 2 + 4), + on.completed(225) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip right completes first", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 4), + on.completed(225) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.completed(220) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.next(215, 2 + 4), + on.completed(225) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 225) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip selector throws", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(220, 3), + on.completed(240) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o1 + .zip( + [&ex](int, int) -> int { + throw ex; + }, + o2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip selector throws N", "[zip][join][operators]"){ + GIVEN("N hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const int N = 16; + + std::runtime_error ex("zip on_error from source"); + + std::vector> e; + for (int i = 0; i < N; ++i) { + e.push_back( + sc.make_hot_observable({ + on.next(210 + 10 * i, 1), + on.completed(500) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return e[0] + .zip( + [&ex](int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int) -> int { + throw ex; + }, + e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error"){ + auto required = rxu::to_vector({ + on.error(200 + 10 * N, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(e.begin(), e.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 200 + 10 * N) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("zip typical N", "[zip][join][operators]"){ + GIVEN("N hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + const int N = 16; + + std::vector> o; + for (int i = 0; i < N; ++i) { + o.push_back( + sc.make_hot_observable({ + on.next(150, 1), + on.next(210 + 10 * i, i + 1), + on.next(410 + 10 * i, i + N + 1), + on.completed(800) + }) + ); + } + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o[0] + .zip( + [](int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, int v9, int v10, int v11, int v12, int v13, int v14, int v15) { + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10 + v11 + v12 + v13 + v14 + v15; + }, + o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10], o[11], o[12], o[13], o[14], o[15] + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.next(200 + 10 * N, N * (N + 1) / 2), + on.next(400 + 10 * N, N * (3 * N + 1) / 2) + }); + required.push_back(on.completed(800)); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to each observable"){ + + std::for_each(o.begin(), o.end(), [&](rxcpp::test::testable_observable &s){ + auto required = rxu::to_vector({ + on.subscribe(200, 800) + }); + auto actual = s.subscriptions(); + REQUIRE(required == actual); + }); + } + } + } +} + +SCENARIO("zip interleaved with tail", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(220, 3), + on.next(230, 5), + on.next(235, 6), + on.next(240, 7), + on.completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.next(220, 2 + 3), + on.next(230, 4 + 5), + on.completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip consecutive", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.completed(230) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(235, 6), + on.next(240, 7), + on.completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints"){ + auto required = rxu::to_vector({ + on.next(235, 2 + 6), + on.next(240, 4 + 7), + on.completed(250) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 250) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip consecutive ends with error left", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.error(230, ex) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(235, 6), + on.next(240, 7), + on.completed(250) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only an error"){ + auto required = rxu::to_vector({ + on.error(230, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 230) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip consecutive ends with error right", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto o1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(215, 2), + on.next(225, 4), + on.completed(250) + }); + + auto o2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(235, 6), + on.next(240, 7), + on.error(245, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return o2 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + o1 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains combined ints followed by an error"){ + auto required = rxu::to_vector({ + on.next(235, 2 + 6), + on.next(240, 4 + 7), + on.error(245, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 245) + }); + auto actual = o1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the o2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 245) + }); + auto actual = o2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip next+error/error", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex1("zip on_error from source 1"); + std::runtime_error ex2("zip on_error from source 2"); + + auto err1 = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.error(220, ex1) + }); + + auto err2 = sc.make_hot_observable({ + on.next(150, 1), + on.error(230, ex2) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err1 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex1) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error/next+error", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex1("zip on_error from source 1"); + std::runtime_error ex2("zip on_error from source 2"); + + auto err1 = sc.make_hot_observable({ + on.next(150, 1), + on.error(230, ex1) + }); + + auto err2 = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.error(220, ex2) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err1 + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err2 + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex2) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err1"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err1.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err2"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err2.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error after completed left", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto ret = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.completed(215) + }); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return ret + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + err + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 215) + }); + auto actual = ret.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("zip error after completed right", "[zip][join][operators]"){ + GIVEN("2 hot observables of ints."){ + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + + std::runtime_error ex("zip on_error from source"); + + auto err = sc.make_hot_observable({ + on.next(150, 1), + on.error(220, ex) + }); + + auto ret = sc.make_hot_observable({ + on.next(150, 1), + on.next(210, 2), + on.completed(215) + }); + + WHEN("each int is combined with the latest from the other source"){ + + auto res = w.start( + [&]() { + return err + .zip( + [](int v2, int v1){ + return v2 + v1; + }, + ret + ) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains only error message"){ + auto required = rxu::to_vector({ + on.error(220, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ret"){ + auto required = rxu::to_vector({ + on.subscribe(200, 215) + }); + auto actual = ret.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the err"){ + auto required = rxu::to_vector({ + on.subscribe(200, 220) + }); + auto actual = err.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index a065376..e5696f3 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -66,6 +66,8 @@ set(TEST_SOURCES ${TEST_DIR}/operators/take.cpp ${TEST_DIR}/operators/take_until.cpp ${TEST_DIR}/operators/window.cpp + ${TEST_DIR}/operators/zip.1.cpp + ${TEST_DIR}/operators/zip.2.cpp ) add_executable(rxcppv2_test ${TEST_SOURCES}) TARGET_LINK_LIBRARIES(rxcppv2_test ${CMAKE_THREAD_LIBS_INIT}) -- GitLab From 537a7d5ba5df2a2781ca4407133f00e2ae2e57c0 Mon Sep 17 00:00:00 2001 From: vkopylov Date: Tue, 21 Oct 2014 02:32:34 -0700 Subject: [PATCH 454/782] Clang compilation fixes --- Rx/v2/test/operators/zip.1.cpp | 4 ++-- Rx/v2/test/operators/zip.2.cpp | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/v2/test/operators/zip.1.cpp b/Rx/v2/test/operators/zip.1.cpp index 5763177..a1313c6 100644 --- a/Rx/v2/test/operators/zip.1.cpp +++ b/Rx/v2/test/operators/zip.1.cpp @@ -69,7 +69,7 @@ SCENARIO("zip never N", "[zip][join][operators]"){ const size_t N = 16; std::vector> n; - for (int i = 0; i < N; ++i) { + for (size_t i = 0; i < N; ++i) { n.push_back( sc.make_hot_observable({ on.next(150, 1) @@ -293,7 +293,7 @@ SCENARIO("zip empty N", "[zip][join][operators]"){ const size_t N = 16; std::vector> e; - for (int i = 0; i < N; ++i) { + for (size_t i = 0; i < N; ++i) { e.push_back( sc.make_hot_observable({ on.next(150, 1), diff --git a/Rx/v2/test/operators/zip.2.cpp b/Rx/v2/test/operators/zip.2.cpp index d56cb83..38eaec7 100644 --- a/Rx/v2/test/operators/zip.2.cpp +++ b/Rx/v2/test/operators/zip.2.cpp @@ -322,12 +322,12 @@ SCENARIO("zip selector throws N", "[zip][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const int N = 16; + const size_t N = 16; std::runtime_error ex("zip on_error from source"); std::vector> e; - for (int i = 0; i < N; ++i) { + for (size_t i = 0; i < N; ++i) { e.push_back( sc.make_hot_observable({ on.next(210 + 10 * i, 1), @@ -380,10 +380,10 @@ SCENARIO("zip typical N", "[zip][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const int N = 16; + const size_t N = 16; std::vector> o; - for (int i = 0; i < N; ++i) { + for (size_t i = 0; i < N; ++i) { o.push_back( sc.make_hot_observable({ on.next(150, 1), -- GitLab From a9391dec38be90bd16c047353e8acea539c4c688 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Wed, 12 Nov 2014 11:56:53 +0300 Subject: [PATCH 455/782] Disable clang optimization that spoils value extracted from list. --- Rx/v2/src/rxcpp/rx-util.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 2f9868c..08310c8 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -594,6 +594,9 @@ struct list_not_empty { struct extract_list_front { template +#ifdef __clang__ + [[clang::optnone]] +#endif auto operator()(std::list& list) -> decltype(std::move(list.front())) { auto val = std::move(list.front()); -- GitLab From 9f8b290bfcf6409dfad6c62089aa0cb1748b1fea Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 13 Nov 2014 13:42:54 +0300 Subject: [PATCH 456/782] [[clang::optnone]] attribute doesn't work on OSX Check whether it is required there at all. --- Rx/v2/src/rxcpp/rx-util.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 08310c8..e51d151 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -594,7 +594,7 @@ struct list_not_empty { struct extract_list_front { template -#ifdef __clang__ +#if defined(__clang__) && defined(__linux__) [[clang::optnone]] #endif auto operator()(std::list& list) -- GitLab From f90dee60427f4b99870b8668ed0e9807f8474d0d Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Thu, 13 Nov 2014 13:59:30 +0300 Subject: [PATCH 457/782] optnone is required for OSX Clang Try to pass it in old fashion. --- Rx/v2/src/rxcpp/rx-util.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index e51d151..b5c3d13 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -594,8 +594,8 @@ struct list_not_empty { struct extract_list_front { template -#if defined(__clang__) && defined(__linux__) - [[clang::optnone]] +#if defined(__clang__) + __attribute__((optnone)) #endif auto operator()(std::list& list) -> decltype(std::move(list.front())) { -- GitLab From f62887a969186c2a2d1671a89a63cabe73d7add0 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 17 Nov 2014 15:49:26 +0300 Subject: [PATCH 458/782] Clean zip sources --- Rx/v2/src/rxcpp/operators/rx-zip.hpp | 9 ++------- Rx/v2/src/rxcpp/rx-util.hpp | 16 ++++++++-------- 2 files changed, 10 insertions(+), 15 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-zip.hpp b/Rx/v2/src/rxcpp/operators/rx-zip.hpp index d3c3ee7..a391c48 100644 --- a/Rx/v2/src/rxcpp/operators/rx-zip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-zip.hpp @@ -94,15 +94,10 @@ struct zip : public operator_base(state->pending); values.push_back(st); - auto lne = rxu::list_not_empty(); - auto avt = rxu::all_values_true(); - if (rxu::apply_to_each(state->pending, lne, avt)) { - //if (rxu::apply_to_each(state->pending, rxu::list_not_empty(), rxu::all_values_true())) { + if (rxu::apply_to_each(state->pending, rxu::list_not_empty(), rxu::all_values_true())) { auto selectedResult = on_exception( [&](){ - auto elf = rxu::extract_list_front(); - return rxu::apply_to_each(state->pending, elf, state->selector); - //return rxu::apply_to_each(state->pending, rxu::extract_list_front(), state->selector); + return rxu::apply_to_each(state->pending, rxu::extract_list_front(), state->selector); }, state->out); if (selectedResult.empty()) { diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index b5c3d13..7a83b7d 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -89,15 +89,15 @@ struct all_true struct all_values_true { template - bool operator()(ValueN... vn); + bool operator()(ValueN... vn) const; template - bool operator()(Value0 v0) { + bool operator()(Value0 v0) const { return v0; } template - bool operator()(Value0 v0, ValueN... vn) { + bool operator()(Value0 v0, ValueN... vn) const { return v0 && all_values_true()(vn...); } }; @@ -145,14 +145,14 @@ auto apply(std::tuple p, values, const F& f) template auto apply_to_each(std::tuple& p, values, F_inner& f_inner, F_outer& f_outer) - -> decltype(f_outer(f_inner(std::get(p))...)) { - return f_outer(f_inner(std::get(p))...); + -> decltype(f_outer(std::move(f_inner(std::get(p)))...)) { + return f_outer(std::move(f_inner(std::get(p)))...); } template auto apply_to_each(std::tuple& p, values, const F_inner& f_inner, const F_outer& f_outer) - -> decltype(f_outer(f_inner(std::forward(std::get(p)))...)) { - return f_outer(f_inner(std::forward(std::get(p)))...); + -> decltype(f_outer(std::move(f_inner(std::get(p)))...)) { + return f_outer(std::move(f_inner(std::get(p)))...); } } @@ -597,7 +597,7 @@ struct extract_list_front { #if defined(__clang__) __attribute__((optnone)) #endif - auto operator()(std::list& list) + auto operator()(std::list& list) const -> decltype(std::move(list.front())) { auto val = std::move(list.front()); list.pop_front(); -- GitLab From 58ce1c8dcbb336785617caa1d6842f07f2ae20b3 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Mon, 17 Nov 2014 18:36:10 +0300 Subject: [PATCH 459/782] Disable clang optimization on extract_list_front() for OSX --- Rx/v2/src/rxcpp/rx-util.hpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 7a83b7d..172720c 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -593,15 +593,24 @@ struct list_not_empty { }; struct extract_list_front { + // Clang optimisation loses moved list.front() value after list.pop_front(), so optimization must be switched off. template -#if defined(__clang__) +#if defined(__clang__) && defined(__linux__) + // Clang on Linux has an attribute to forbid optimization __attribute__((optnone)) #endif auto operator()(std::list& list) const -> decltype(std::move(list.front())) { +#if defined(__clang__) && !defined(__linux__) + // Clang on OSX doesn't support the attribute + volatile auto val = std::move(list.front()); + list.pop_front(); + return std::move(const_cast(val)); +#else auto val = std::move(list.front()); list.pop_front(); return std::move(val); +#endif } }; -- GitLab From 725017e02ee7df9f6998de8eee7baee62e6dc756 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 18 Nov 2014 12:04:34 +0300 Subject: [PATCH 460/782] Add buffer/window with time&count operators including tests --- .../rxcpp/operators/rx-buffer_time_count.hpp | 146 ++++++++++++++ .../rxcpp/operators/rx-window_time_count.hpp | 147 ++++++++++++++ Rx/v2/src/rxcpp/rx-observable.hpp | 35 ++++ Rx/v2/src/rxcpp/rx-operators.hpp | 2 + Rx/v2/test/operators/buffer.cpp | 171 ++++++++++++++++ Rx/v2/test/operators/window.cpp | 186 ++++++++++++++++++ 6 files changed, 687 insertions(+) create mode 100644 Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp create mode 100644 Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp new file mode 100644 index 0000000..ef12662 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp @@ -0,0 +1,146 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_buffer_with_time_or_count_HPP) +#define RXCPP_OPERATORS_RX_buffer_with_time_or_count_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct buffer_with_time_or_count +{ + static_assert(std::is_convertible::value, "Duration parameter must convert to rxsc::scheduler::clock_type::duration"); + static_assert(is_coordination::value, "Coordination parameter must satisfy the requirements for a Coordination"); + + typedef typename std::decay::type source_value_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + typedef typename std::decay::type duration_type; + + struct buffer_with_time_or_count_values + { + buffer_with_time_or_count_values(duration_type p, int n, coordination_type c) + : period(p) + , count(n) + , coordination(c) + { + } + duration_type period; + int count; + coordination_type coordination; + }; + buffer_with_time_or_count_values initial; + + buffer_with_time_or_count(duration_type period, int count, coordination_type coordination) + : initial(period, count, coordination) + { + } + + template + struct buffer_with_time_or_count_observer : public buffer_with_time_or_count_values + { + typedef buffer_with_time_or_count_observer this_type; + typedef std::vector value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + + dest_type dest; + coordinator_type coordinator; + rxsc::worker worker; + mutable int number; + mutable int chunk_id; + mutable value_type chunk; + + buffer_with_time_or_count_observer(dest_type d, buffer_with_time_or_count_values v, coordinator_type c) + : buffer_with_time_or_count_values(v) + , dest(std::move(d)) + , coordinator(std::move(c)) + , worker(std::move(coordinator.get_worker())) + , number(0) + , chunk_id(0) + { + auto new_id = chunk_id; + auto produce_time = worker.now() + period; + worker.schedule(produce_time, [=](const rxsc::schedulable&){produce_buffer(new_id, produce_time);}); + } + + void produce_buffer(int id, rxsc::scheduler::clock_type::time_point expected) const { + if (id != chunk_id) + return; + + dest.on_next(chunk); + chunk.resize(0); + number = 0; + auto new_id = ++chunk_id; + auto produce_time = expected + period; + worker.schedule(produce_time, [=](const rxsc::schedulable&){produce_buffer(new_id, produce_time);}); + } + + void on_next(T v) const { + chunk.push_back(v); + if (++number == count) { + produce_buffer(chunk_id, worker.now()); + } + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_next(chunk); + chunk_id += 1; + dest.on_completed(); + } + + static subscriber> make(dest_type d, buffer_with_time_or_count_values v) { + auto cs = d.get_subscription(); + auto coordinator = v.coordination.create_coordinator(cs); + + return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v), std::move(coordinator))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(buffer_with_time_or_count_observer::make(std::move(dest), initial)) { + return buffer_with_time_or_count_observer::make(std::move(dest), initial); + } +}; + +template +class buffer_with_time_or_count_factory +{ + typedef typename std::decay::type duration_type; + typedef typename std::decay::type coordination_type; + + duration_type period; + duration_type skip; + coordination_type coordination; +public: + buffer_with_time_or_count_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} + template + auto operator()(Observable&& source) + -> decltype(source.template lift::type::value_type>>(buffer_with_time_or_count::type::value_type, Duration, Coordination>(period, skip, coordination))) { + return source.template lift::type::value_type>>(buffer_with_time_or_count::type::value_type, Duration, Coordination>(period, skip, coordination)); + } +}; + +} + +template +inline auto buffer_with_time_or_count(Duration period, int count, Coordination coordination) + -> detail::buffer_with_time_or_count_factory { + return detail::buffer_with_time_or_count_factory(period, count, coordination); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp new file mode 100644 index 0000000..ef2f13e --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp @@ -0,0 +1,147 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_WINDOW_WITH_TIME_OR_COUNT_HPP) +#define RXCPP_OPERATORS_RX_WINDOW_WITH_TIME_OR_COUNT_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct window_with_time_or_count +{ + typedef typename std::decay::type source_value_type; + typedef typename std::decay::type coordination_type; + typedef typename coordination_type::coordinator_type coordinator_type; + typedef typename std::decay::type duration_type; + + struct window_with_time_or_count_values + { + window_with_time_or_count_values(duration_type p, int n, coordination_type c) + : period(p) + , count(n) + , coordination(c) + { + } + duration_type period; + int count; + coordination_type coordination; + }; + window_with_time_or_count_values initial; + + window_with_time_or_count(duration_type period, int count, coordination_type coordination) + : initial(period, count, coordination) + { + } + + template + struct window_with_time_or_count_observer : public window_with_time_or_count_values, public observer_base> + { + typedef window_with_time_or_count_observer this_type; + typedef observer_base> base_type; + typedef typename base_type::value_type value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + coordinator_type coordinator; + rxsc::worker worker; + mutable int number; + mutable int subj_id; + mutable rxcpp::subjects::subject subj; + + window_with_time_or_count_observer(dest_type d, window_with_time_or_count_values v, coordinator_type c) + : window_with_time_or_count_values(v) + , dest(std::move(d)) + , coordinator(std::move(c)) + , worker(std::move(coordinator.get_worker())) + , number(0) + , subj_id(0) + { + dest.on_next(subj.get_observable().as_dynamic()); + auto new_id = subj_id; + auto produce_time = worker.now() + period; + worker.schedule(produce_time, [=](const rxsc::schedulable&){release_window(new_id, produce_time);}); + } + + void release_window(int id, rxsc::scheduler::clock_type::time_point expected) const { + if (id != subj_id) + return; + + subj.get_subscriber().on_completed(); + subj = rxcpp::subjects::subject(); + dest.on_next(subj.get_observable().as_dynamic()); + number = 0; + auto new_id = ++subj_id; + auto produce_time = expected + period; + worker.schedule(produce_time, [=](const rxsc::schedulable&){release_window(new_id, produce_time);}); + } + + void on_next(T v) const { + subj.get_subscriber().on_next(v); + if (++number == count) { + release_window(subj_id, worker.now()); + } + } + + void on_error(std::exception_ptr e) const { + subj.get_subscriber().on_error(e); + dest.on_error(e); + } + + void on_completed() const { + subj.get_subscriber().on_completed(); + dest.on_completed(); + } + + static subscriber make(dest_type d, window_with_time_or_count_values v) { + auto cs = d.get_subscription(); + auto coordinator = v.coordination.create_coordinator(cs); + + return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(v), std::move(coordinator)))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(window_with_time_or_count_observer::make(std::move(dest), initial)) { + return window_with_time_or_count_observer::make(std::move(dest), initial); + } +}; + +template +class window_with_time_or_count_factory +{ + typedef typename std::decay::type duration_type; + typedef typename std::decay::type coordination_type; + + duration_type period; + int count; + coordination_type coordination; +public: + window_with_time_or_count_factory(duration_type p, int n, coordination_type c) : period(p), count(n), coordination(c) {} + template + auto operator()(Observable&& source) + -> decltype(source.template lift::type::value_type>>(window_with_time_or_count::type::value_type, Duration, Coordination>(period, count, coordination))) { + return source.template lift::type::value_type>>(window_with_time_or_count::type::value_type, Duration, Coordination>(period, count, coordination)); + } +}; + +} + +template +inline auto window_with_time_or_count(Duration period, int count, Coordination coordination) + -> detail::window_with_time_or_count_factory { + return detail::window_with_time_or_count_factory(period, count, coordination); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 61ada1a..c9efdc8 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -558,6 +558,24 @@ public: return lift>(rxo::detail::window_with_time(period, period, identity_current_thread())); } + /// window_with_time_or_count -> + /// produce observables every skip time interval and collect items from this observable for period of time into each produced observable. + /// + template + auto window_with_time_or_count(Duration period, int count, Coordination coordination) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window_with_time_or_count(period, count, coordination))) { + return lift>(rxo::detail::window_with_time_or_count(period, count, coordination)); + } + + /// window_with_time_or_count -> + /// produce observables every skip time interval and collect items from this observable for period of time into each produced observable. + /// + template + auto window_with_time_or_count(Duration period, int count) const + -> decltype(EXPLICIT_THIS lift>(rxo::detail::window_with_time_or_count(period, count, identity_current_thread()))) { + return lift>(rxo::detail::window_with_time_or_count(period, count, identity_current_thread())); + } + /// buffer -> /// collect count items from this observable and produce a vector of them to emit from the new observable that is returned. /// @@ -609,6 +627,23 @@ public: return lift_if>(rxo::detail::buffer_with_time(period, period, identity_current_thread())); } + /// buffer_with_time_or_count -> + /// start a new vector every skip time interval and collect items into it from this observable for period of time. + /// + template + auto buffer_with_time_or_count(rxsc::scheduler::clock_type::duration period, int count, Coordination coordination) const + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_with_time_or_count(period, count, coordination))) { + return lift_if>(rxo::detail::buffer_with_time_or_count(period, count, coordination)); + } + + /// buffer_with_time_or_count -> + /// start a new vector every skip time interval and collect items into it from this observable for period of time. + /// + auto buffer_with_time_or_count(rxsc::scheduler::clock_type::duration period, int count) const + -> decltype(EXPLICIT_THIS lift_if>(rxo::detail::buffer_with_time_or_count(period, count, identity_current_thread()))) { + return lift_if>(rxo::detail::buffer_with_time_or_count(period, count, identity_current_thread())); + } + template struct defer_switch_on_next : public defer_observable< is_observable, diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index e9c4931..37f443e 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -36,6 +36,7 @@ namespace rxo=operators; #include "operators/rx-buffer_count.hpp" #include "operators/rx-buffer_time.hpp" +#include "operators/rx-buffer_time_count.hpp" #include "operators/rx-combine_latest.hpp" #include "operators/rx-concat.hpp" #include "operators/rx-concat_map.hpp" @@ -66,5 +67,6 @@ namespace rxo=operators; #include "operators/rx-take_until.hpp" #include "operators/rx-window.hpp" #include "operators/rx-window_time.hpp" +#include "operators/rx-window_time_count.hpp" #include "operators/rx-zip.hpp" #endif diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index b3103ea..62bd1bd 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -954,3 +954,174 @@ SCENARIO("buffer with time, same", "[buffer_with_time][operators]"){ } } } + +SCENARIO("buffer with time or count, basic", "[buffer_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + WHEN("group ints on intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time_or_count(milliseconds(70), 3, so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(240, rxu::to_vector({ 1, 2, 3 })), + v_on.next(310, rxu::to_vector({ 4 })), + v_on.next(370, rxu::to_vector({ 5, 6, 7 })), + v_on.next(440, rxu::to_vector({ 8 })), + v_on.next(510, rxu::to_vector({ 9 })), + v_on.next(580, std::vector()), + v_on.next(600, std::vector()), + v_on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer with time or count, error", "[buffer_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + std::runtime_error ex("buffer_with_time on_error from source"); + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) + }); + WHEN("group ints on intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time_or_count(milliseconds(70), 3, so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(240, rxu::to_vector({ 1, 2, 3 })), + v_on.next(310, rxu::to_vector({ 4 })), + v_on.next(370, rxu::to_vector({ 5, 6, 7 })), + v_on.next(440, rxu::to_vector({ 8 })), + v_on.next(510, rxu::to_vector({ 9 })), + v_on.next(580, std::vector()), + v_on.error(600, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("buffer with time or count, dispose", "[buffer_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + WHEN("group ints on intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time_or_count(milliseconds(70), 3, so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 370 + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(240, rxu::to_vector({ 1, 2, 3 })), + v_on.next(310, rxu::to_vector({ 4 })), + v_on.next(370, rxu::to_vector({ 5, 6, 7 })), + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 370) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index 141a07c..931f694 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -748,3 +748,189 @@ SCENARIO("window with time, basic same 1", "[window_with_time][operators]"){ } } } + +SCENARIO("window with time or count, basic", "[window_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time_or_count(milliseconds(70), 3, so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time or count, error", "[window_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + std::runtime_error ex("window_with_time on_error from source"); + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time_or_count(milliseconds(70), 3, so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.error(600, ex) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 600) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} + +SCENARIO("window with time or count, disposed", "[window_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7), + on.next(420, 8), + on.next(470, 9), + on.completed(600) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time_or_count(milliseconds(70), 3, so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + }, + 370 + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(205, 1), + on.next(210, 2), + on.next(240, 3), + on.next(280, 4), + on.next(320, 5), + on.next(350, 6), + on.next(370, 7) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 370) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From 83c60a85399be619ffc52154c8ef805052d9d436 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Tue, 18 Nov 2014 12:21:59 +0300 Subject: [PATCH 461/782] Clean buffer/window code --- Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp | 10 +++------- Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp | 8 ++++---- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp index ef12662..e8b49be 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp @@ -2,8 +2,8 @@ #pragma once -#if !defined(RXCPP_OPERATORS_RX_buffer_with_time_or_count_HPP) -#define RXCPP_OPERATORS_RX_buffer_with_time_or_count_HPP +#if !defined(RXCPP_OPERATORS_RX_BUFFER_WITH_TIME_OR_COUNT_HPP) +#define RXCPP_OPERATORS_RX_BUFFER_WITH_TIME_OR_COUNT_HPP #include "../rx-includes.hpp" @@ -54,7 +54,6 @@ struct buffer_with_time_or_count dest_type dest; coordinator_type coordinator; rxsc::worker worker; - mutable int number; mutable int chunk_id; mutable value_type chunk; @@ -63,7 +62,6 @@ struct buffer_with_time_or_count , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) - , number(0) , chunk_id(0) { auto new_id = chunk_id; @@ -77,7 +75,6 @@ struct buffer_with_time_or_count dest.on_next(chunk); chunk.resize(0); - number = 0; auto new_id = ++chunk_id; auto produce_time = expected + period; worker.schedule(produce_time, [=](const rxsc::schedulable&){produce_buffer(new_id, produce_time);}); @@ -85,7 +82,7 @@ struct buffer_with_time_or_count void on_next(T v) const { chunk.push_back(v); - if (++number == count) { + if (int(chunk.size()) == count) { produce_buffer(chunk_id, worker.now()); } } @@ -94,7 +91,6 @@ struct buffer_with_time_or_count } void on_completed() const { dest.on_next(chunk); - chunk_id += 1; dest.on_completed(); } diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp index ef2f13e..95a2aeb 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp @@ -51,7 +51,7 @@ struct window_with_time_or_count dest_type dest; coordinator_type coordinator; rxsc::worker worker; - mutable int number; + mutable int cursor; mutable int subj_id; mutable rxcpp::subjects::subject subj; @@ -60,7 +60,7 @@ struct window_with_time_or_count , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) - , number(0) + , cursor(0) , subj_id(0) { dest.on_next(subj.get_observable().as_dynamic()); @@ -76,7 +76,7 @@ struct window_with_time_or_count subj.get_subscriber().on_completed(); subj = rxcpp::subjects::subject(); dest.on_next(subj.get_observable().as_dynamic()); - number = 0; + cursor = 0; auto new_id = ++subj_id; auto produce_time = expected + period; worker.schedule(produce_time, [=](const rxsc::schedulable&){release_window(new_id, produce_time);}); @@ -84,7 +84,7 @@ struct window_with_time_or_count void on_next(T v) const { subj.get_subscriber().on_next(v); - if (++number == count) { + if (++cursor == count) { release_window(subj_id, worker.now()); } } -- GitLab From afb7f6263f72c4feaded6d6a34c2be7fba197ba2 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Fri, 21 Nov 2014 12:11:35 +0300 Subject: [PATCH 462/782] Fix accessing to non-existed instance issue on buffer/windows with time&count * Move class data to state object * Do not use pointer to this inside lambda * Add test for time only triggered buffer/window --- .../rxcpp/operators/rx-buffer_time_count.hpp | 69 ++++++++++------ .../rxcpp/operators/rx-window_time_count.hpp | 82 +++++++++++-------- Rx/v2/test/operators/buffer.cpp | 54 ++++++++++++ Rx/v2/test/operators/window.cpp | 54 ++++++++++++ 4 files changed, 199 insertions(+), 60 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp index e8b49be..ea4d608 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp @@ -44,54 +44,69 @@ struct buffer_with_time_or_count } template - struct buffer_with_time_or_count_observer : public buffer_with_time_or_count_values + struct buffer_with_time_or_count_observer { typedef buffer_with_time_or_count_observer this_type; typedef std::vector value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; - dest_type dest; - coordinator_type coordinator; - rxsc::worker worker; - mutable int chunk_id; - mutable value_type chunk; + struct buffer_with_time_or_count_subscriber_values : public buffer_with_time_or_count_values + { + buffer_with_time_or_count_subscriber_values(dest_type d, buffer_with_time_or_count_values v, coordinator_type c) + : buffer_with_time_or_count_values(std::move(v)) + , dest(std::move(d)) + , coordinator(std::move(c)) + , worker(std::move(coordinator.get_worker())) + , chunk_id(0) + { + } + dest_type dest; + coordinator_type coordinator; + rxsc::worker worker; + mutable int chunk_id; + mutable value_type chunk; + }; + typedef std::shared_ptr state_type; + state_type state; buffer_with_time_or_count_observer(dest_type d, buffer_with_time_or_count_values v, coordinator_type c) - : buffer_with_time_or_count_values(v) - , dest(std::move(d)) - , coordinator(std::move(c)) - , worker(std::move(coordinator.get_worker())) - , chunk_id(0) + : state(std::make_shared(buffer_with_time_or_count_subscriber_values(std::move(d), std::move(v), std::move(c)))) { - auto new_id = chunk_id; - auto produce_time = worker.now() + period; - worker.schedule(produce_time, [=](const rxsc::schedulable&){produce_buffer(new_id, produce_time);}); + auto new_id = state->chunk_id; + auto produce_time = state->worker.now() + state->period; + auto localState = state; + state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ + produce_buffer(new_id, produce_time, localState); + }); } - void produce_buffer(int id, rxsc::scheduler::clock_type::time_point expected) const { - if (id != chunk_id) + static void produce_buffer(int id, rxsc::scheduler::clock_type::time_point expected, state_type state) { + if (id != state->chunk_id) return; - dest.on_next(chunk); - chunk.resize(0); - auto new_id = ++chunk_id; - auto produce_time = expected + period; - worker.schedule(produce_time, [=](const rxsc::schedulable&){produce_buffer(new_id, produce_time);}); + state->dest.on_next(state->chunk); + state->chunk.resize(0); + auto new_id = ++state->chunk_id; + auto produce_time = expected + state->period; + auto localState = state; + state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ + produce_buffer(new_id, produce_time, localState); + }); } void on_next(T v) const { - chunk.push_back(v); - if (int(chunk.size()) == count) { - produce_buffer(chunk_id, worker.now()); + state->chunk.push_back(v); + if (int(state->chunk.size()) == state->count) { + produce_buffer(state->chunk_id, state->worker.now(), state); } } void on_error(std::exception_ptr e) const { - dest.on_error(e); + state->dest.on_error(e); } void on_completed() const { - dest.on_next(chunk); - dest.on_completed(); + state->dest.on_next(state->chunk); + state->dest.on_completed(); } static subscriber> make(dest_type d, buffer_with_time_or_count_values v) { diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp index 95a2aeb..a3e45f4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp @@ -41,62 +41,78 @@ struct window_with_time_or_count } template - struct window_with_time_or_count_observer : public window_with_time_or_count_values, public observer_base> + struct window_with_time_or_count_observer : public observer_base> { typedef window_with_time_or_count_observer this_type; typedef observer_base> base_type; typedef typename base_type::value_type value_type; typedef typename std::decay::type dest_type; typedef observer observer_type; - dest_type dest; - coordinator_type coordinator; - rxsc::worker worker; - mutable int cursor; - mutable int subj_id; - mutable rxcpp::subjects::subject subj; + + struct window_with_time_or_count_subscriber_values : public window_with_time_or_count_values + { + window_with_time_or_count_subscriber_values(dest_type d, window_with_time_or_count_values v, coordinator_type c) + : window_with_time_or_count_values(std::move(v)) + , dest(std::move(d)) + , coordinator(std::move(c)) + , worker(std::move(coordinator.get_worker())) + , cursor(0) + , subj_id(0) + { + } + dest_type dest; + coordinator_type coordinator; + rxsc::worker worker; + mutable int cursor; + mutable int subj_id; + mutable rxcpp::subjects::subject subj; + }; + typedef std::shared_ptr state_type; + state_type state; window_with_time_or_count_observer(dest_type d, window_with_time_or_count_values v, coordinator_type c) - : window_with_time_or_count_values(v) - , dest(std::move(d)) - , coordinator(std::move(c)) - , worker(std::move(coordinator.get_worker())) - , cursor(0) - , subj_id(0) + : state(std::make_shared(window_with_time_or_count_subscriber_values(std::move(d), std::move(v), std::move(c)))) { - dest.on_next(subj.get_observable().as_dynamic()); - auto new_id = subj_id; - auto produce_time = worker.now() + period; - worker.schedule(produce_time, [=](const rxsc::schedulable&){release_window(new_id, produce_time);}); + state->dest.on_next(state->subj.get_observable().as_dynamic()); + auto new_id = state->subj_id; + auto produce_time = state->worker.now() + state->period; + auto localState = state; + state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ + release_window(new_id, produce_time, localState); + }); } - void release_window(int id, rxsc::scheduler::clock_type::time_point expected) const { - if (id != subj_id) + static void release_window(int id, rxsc::scheduler::clock_type::time_point expected, state_type state) { + if (id != state->subj_id) return; - subj.get_subscriber().on_completed(); - subj = rxcpp::subjects::subject(); - dest.on_next(subj.get_observable().as_dynamic()); - cursor = 0; - auto new_id = ++subj_id; - auto produce_time = expected + period; - worker.schedule(produce_time, [=](const rxsc::schedulable&){release_window(new_id, produce_time);}); + state->subj.get_subscriber().on_completed(); + state->subj = rxcpp::subjects::subject(); + state->dest.on_next(state->subj.get_observable().as_dynamic()); + state->cursor = 0; + auto new_id = ++state->subj_id; + auto produce_time = expected + state->period; + auto localState = state; + state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ + release_window(new_id, produce_time, localState); + }); } void on_next(T v) const { - subj.get_subscriber().on_next(v); - if (++cursor == count) { - release_window(subj_id, worker.now()); + state->subj.get_subscriber().on_next(v); + if (++state->cursor == state->count) { + release_window(state->subj_id, state->worker.now(), state); } } void on_error(std::exception_ptr e) const { - subj.get_subscriber().on_error(e); - dest.on_error(e); + state->subj.get_subscriber().on_error(e); + state->dest.on_error(e); } void on_completed() const { - subj.get_subscriber().on_completed(); - dest.on_completed(); + state->subj.get_subscriber().on_completed(); + state->dest.on_completed(); } static subscriber make(dest_type d, window_with_time_or_count_values v) { diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index 62bd1bd..5f97583 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -1125,3 +1125,57 @@ SCENARIO("buffer with time or count, dispose", "[buffer_with_time_or_count][oper } } } + +SCENARIO("buffer with time or count, only time triggered", "[buffer_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> v_on; + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(305, 2), + on.next(505, 3), + on.next(605, 4), + on.next(610, 5), + on.completed(850) + }); + WHEN("group ints on intervals"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .buffer_with_time_or_count(milliseconds(100), 3, so) + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains groups of ints"){ + auto required = rxu::to_vector({ + v_on.next(300, rxu::to_vector({ 1 })), + v_on.next(400, rxu::to_vector({ 2 })), + v_on.next(500, std::vector()), + v_on.next(600, rxu::to_vector({ 3 })), + v_on.next(700, rxu::to_vector({ 4, 5 })), + v_on.next(800, std::vector()), + v_on.next(850, std::vector()), + v_on.completed(850) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the xs"){ + auto required = rxu::to_vector({ + on.subscribe(200, 850) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index 931f694..f7b0e78 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -934,3 +934,57 @@ SCENARIO("window with time or count, disposed", "[window_with_time_or_count][ope } } } + +SCENARIO("window with time or count, only time triggered", "[window_with_time_or_count][operators]"){ + GIVEN("1 hot observable of ints."){ + auto sc = rxsc::make_test(); + auto so = rx::synchronize_in_one_worker(sc); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> o_on; + + auto xs = sc.make_hot_observable({ + on.next(205, 1), + on.next(305, 2), + on.next(505, 3), + on.next(605, 4), + on.next(610, 5), + on.completed(850) + }); + + WHEN("group each int with the next 2 ints"){ + using namespace std::chrono; + + auto res = w.start( + [&]() { + return xs + .window_with_time_or_count(milliseconds(100), 3, so) + .merge() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains merged groups of ints"){ + auto required = rxu::to_vector({ + on.next(205, 1), + on.next(305, 2), + on.next(505, 3), + on.next(605, 4), + on.next(610, 5), + on.completed(850) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the observable"){ + auto required = rxu::to_vector({ + o_on.subscribe(200, 850) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + } + } +} -- GitLab From e283ca7fcfd9ec594543e26590e1eaac629060cc Mon Sep 17 00:00:00 2001 From: Andreas Reischuck Date: Fri, 14 Nov 2014 20:26:41 +0100 Subject: [PATCH 463/782] added markdown code syntax hints --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index ed8a4f3..bcdc3b3 100644 --- a/README.md +++ b/README.md @@ -31,14 +31,14 @@ RxCpp uses CMake to create build files for several platforms and IDE's ###Ide builds ####XCode -``` +```shell mkdir projects/build cd projects/build cmake -G"Xcode" ../CMake -B. ``` ####Visual Studio 13 -``` +```batch mkdir projects\build cd projects\build cmake -G"Visual Studio 12" ..\CMake -B. @@ -48,7 +48,7 @@ cmake -G"Visual Studio 12" ..\CMake -B. ###makefile builds ####OSX -``` +```shell mkdir projects/build cd projects/build cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake @@ -56,7 +56,7 @@ make ``` ####Linux --- Clang -``` +```shell mkdir projects/build cd projects/build cmake -G"Unix Makefiles" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake @@ -64,7 +64,7 @@ make ``` ####Linux --- GCC -``` +```shell mkdir projects/build cd projects/build cmake -G"Unix Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ../CMake @@ -72,7 +72,7 @@ make ``` ####Windows -``` +```batch mkdir projects\build cd projects\build cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo -B. ..\CMake @@ -93,7 +93,7 @@ Example of by-tag #Using RxCpp Add ```Rx/v2/src``` to the include paths -``` +```cpp #include "rxcpp/rx.hpp" // create alias' to simplify code // these are owned by the user so that -- GitLab From 262a3b48dc44114c53504c48d67c03dfc218fc60 Mon Sep 17 00:00:00 2001 From: Tim Cheeseman Date: Mon, 26 Jan 2015 18:51:42 -0500 Subject: [PATCH 464/782] Implement pairwise operator --- Rx/v2/src/rxcpp/operators/rx-pairwise.hpp | 86 +++++++++++++++++++++++ Rx/v2/src/rxcpp/rx-includes.hpp | 1 + Rx/v2/src/rxcpp/rx-observable.hpp | 9 ++- Rx/v2/src/rxcpp/rx-operators.hpp | 1 + Rx/v2/test/operators/pairwise.cpp | 50 +++++++++++++ projects/CMake/CMakeLists.txt | 1 + 6 files changed, 147 insertions(+), 1 deletion(-) create mode 100644 Rx/v2/src/rxcpp/operators/rx-pairwise.hpp create mode 100644 Rx/v2/test/operators/pairwise.cpp diff --git a/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp b/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp new file mode 100644 index 0000000..582aba5 --- /dev/null +++ b/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp @@ -0,0 +1,86 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information. + +#pragma once + +#if !defined(RXCPP_OPERATORS_RX_PAIRWISE_HPP) +#define RXCPP_OPERATORS_RX_PAIRWISE_HPP + +#include "../rx-includes.hpp" + +namespace rxcpp { + +namespace operators { + +namespace detail { + +template +struct pairwise +{ + typedef typename std::decay::type source_value_type; + typedef std::tuple value_type; + + template + struct pairwise_observer + { + typedef pairwise_observer this_type; + typedef std::tuple value_type; + typedef typename std::decay::type dest_type; + typedef observer observer_type; + dest_type dest; + mutable rxu::detail::maybe remembered; + + pairwise_observer(dest_type d) + : dest(std::move(d)) + { + } + void on_next(source_value_type v) const { + if (remembered.empty()) { + remembered.reset(v); + return; + } + + dest.on_next(std::make_tuple(remembered.get(), v)); + remembered.reset(v); + } + void on_error(std::exception_ptr e) const { + dest.on_error(e); + } + void on_completed() const { + dest.on_completed(); + } + + static subscriber make(dest_type d) { + auto cs = d.get_subscription(); + return make_subscriber(std::move(cs), observer_type(this_type(std::move(d)))); + } + }; + + template + auto operator()(Subscriber dest) const + -> decltype(pairwise_observer::make(std::move(dest))) { + return pairwise_observer::make(std::move(dest)); + } +}; + +class pairwise_factory +{ +public: + template + auto operator()(Observable&& source) + -> decltype(source.template lift::type::value_type>::value_type>(pairwise::type::value_type>())) { + return source.template lift::type::value_type>::value_type>(pairwise::type::value_type>()); + } +}; + +} + +inline auto pairwise() + -> detail::pairwise_factory { + return detail::pairwise_factory(); +} + +} + +} + +#endif diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 5ca50e1..1ac9de7 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -118,6 +118,7 @@ #include #include #include +#include #include "rx-util.hpp" #include "rx-predef.hpp" diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index c9efdc8..5f15ef6 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -1013,7 +1013,7 @@ public: return observable_type(operator_type(identity_current_thread(), rxu::pack(), std::make_tuple(src, std::move(on)...))); }; }; - + /// zip -> /// bring by one item from all given observables and use the Selector to select a value to emit from the new observable that is returned. /// @@ -1311,6 +1311,13 @@ public: return rxo::start_with(*this, std::move(v0), std::move(vn)...); } + /// pairwise -> + /// take values pairwise from the observable + /// + auto pairwise() const + -> decltype(EXPLICIT_THIS lift::value_type>(rxo::detail::pairwise())) { + return lift::value_type>(rxo::detail::pairwise()); + } }; template diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 37f443e..5e4e042 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -51,6 +51,7 @@ namespace rxo=operators; #include "operators/rx-merge.hpp" #include "operators/rx-multicast.hpp" #include "operators/rx-observe_on.hpp" +#include "operators/rx-pairwise.hpp" #include "operators/rx-publish.hpp" #include "operators/rx-reduce.hpp" #include "operators/rx-ref_count.hpp" diff --git a/Rx/v2/test/operators/pairwise.cpp b/Rx/v2/test/operators/pairwise.cpp new file mode 100644 index 0000000..cb0a888 --- /dev/null +++ b/Rx/v2/test/operators/pairwise.cpp @@ -0,0 +1,50 @@ +#include "rxcpp/rx.hpp" +namespace rxu=rxcpp::util; +namespace rxsc=rxcpp::schedulers; + +#include "rxcpp/rx-test.hpp" +#include "catch.hpp" + +SCENARIO("pairwise", "[pairwise][operators]") { + GIVEN("a cold observable of n ints") { + auto sc = rxsc::make_test(); + auto w = sc.create_worker(); + const rxsc::test::messages on; + const rxsc::test::messages> on_pairwise; + long invoked = 0; + + auto xs = sc.make_cold_observable({ + on.next(180, 1), + on.next(210, 2), + on.next(240, 3), + on.next(290, 4), + on.next(350, 5), + on.completed(400), + }); + + WHEN("taken pairwise") { + + auto res = w.start( + [xs, &invoked]() { + return xs + .pairwise() + // forget type to workaround lambda deduction bug on msvc 2013 + .as_dynamic(); + } + ); + + THEN("the output contains n-1 tuples of ints"){ + auto delay = rxcpp::schedulers::test::subscribed_time; + auto required = rxu::to_vector({ + on_pairwise.next(210 + delay, std::make_tuple(1, 2)), + on_pairwise.next(240 + delay, std::make_tuple(2, 3)), + on_pairwise.next(290 + delay, std::make_tuple(3, 4)), + on_pairwise.next(350 + delay, std::make_tuple(4, 5)), + on_pairwise.completed(400 + delay) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + } + } +} diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index e5696f3..a951c2d 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -54,6 +54,7 @@ set(TEST_SOURCES ${TEST_DIR}/operators/map.cpp ${TEST_DIR}/operators/merge.cpp ${TEST_DIR}/operators/observe_on.cpp + ${TEST_DIR}/operators/pairwise.cpp ${TEST_DIR}/operators/publish.cpp ${TEST_DIR}/operators/reduce.cpp ${TEST_DIR}/operators/repeat.cpp -- GitLab From 098b6aa734839cc33c379a60472db5305e05f270 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 27 Jan 2015 19:24:59 -0800 Subject: [PATCH 465/782] move to trusty apt repo for clang --- projects/scripts/travis-install.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index c6f9458..6712002 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -5,10 +5,10 @@ set -e #if OS is linux or is not set if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key|sudo apt-key add - - sudo add-apt-repository -y 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise main' + sudo add-apt-repository -y 'deb http://llvm.org/apt/trusty/ llvm-toolchain-trusty main' sudo add-apt-repository -y "deb http://us.archive.ubuntu.com/ubuntu/ trusty main universe" sudo add-apt-repository -y ppa:28msec/utils # Recent cmake - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang-3.5 + sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang sudo apt-get clean -qq || echo "ignore clean failure" sudo apt-get update -qq || echo "ignore update failure" -- GitLab From e32cc0c6261622e182ef6f383911a0454dda92cd Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Sat, 31 Jan 2015 09:15:42 -0800 Subject: [PATCH 466/782] fixes #58 concat_map_factory initialiser list passes arguments in the wrong order --- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 4 +- Rx/v2/test/operators/concat_map.cpp | 51 +++++++++++++++++ Rx/v2/test/operators/flat_map.cpp | 61 +++++++++++++++++++++ 4 files changed, 116 insertions(+), 4 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index a8be1a7..e5ea951 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -250,8 +250,8 @@ class concat_map_factory coordination_type coordination; public: concat_map_factory(collection_selector_type s, result_selector_type rs, coordination_type sf) - : selectorCollection(std::move(rs)) - , selectorResult(std::move(s)) + : selectorCollection(std::move(s)) + , selectorResult(std::move(rs)) , coordination(std::move(sf)) { } diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index f8fd1d7..f50ed43 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -233,8 +233,8 @@ class flat_map_factory coordination_type coordination; public: flat_map_factory(collection_selector_type s, result_selector_type rs, coordination_type sf) - : selectorCollection(std::move(rs)) - , selectorResult(std::move(s)) + : selectorCollection(std::move(s)) + , selectorResult(std::move(rs)) , coordination(std::move(sf)) { } diff --git a/Rx/v2/test/operators/concat_map.cpp b/Rx/v2/test/operators/concat_map.cpp index 8423e46..b82749a 100644 --- a/Rx/v2/test/operators/concat_map.cpp +++ b/Rx/v2/test/operators/concat_map.cpp @@ -2,6 +2,7 @@ namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxs=rxcpp::sources; +namespace rxo=rxcpp::operators; namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" @@ -269,6 +270,56 @@ SCENARIO("concat_map completes", "[concat_map][map][operators]"){ REQUIRE(required == actual); } } + + WHEN("streamed each int is mapped to the strings"){ + + auto res = w.start( + [&]() { + return xs >> + rxo::concat_map( + [&](int){ + return ys;}, + [](int, std::string s){ + return s;}, + rx::identity_current_thread()) >> + // forget type to workaround lambda deduction bug on msvc 2013 + rxo::as_dynamic(); + } + ); + + THEN("the output contains strings repeated for each int"){ + auto required = rxu::to_vector({ + s_on.next(350, "foo"), + s_on.next(400, "bar"), + s_on.next(450, "baz"), + s_on.next(500, "qux"), + s_on.next(600, "foo"), + s_on.next(650, "bar"), + s_on.next(700, "baz"), + s_on.next(750, "qux"), + s_on.completed(800) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + auto required = rxu::to_vector({ + i_on.subscribe(200, 700) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were 2 subscription and unsubscription to the strings"){ + auto required = rxu::to_vector({ + s_on.subscribe(300, 550), + s_on.subscribe(550, 800) + }); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + } } } diff --git a/Rx/v2/test/operators/flat_map.cpp b/Rx/v2/test/operators/flat_map.cpp index 44b6869..5a68023 100644 --- a/Rx/v2/test/operators/flat_map.cpp +++ b/Rx/v2/test/operators/flat_map.cpp @@ -2,6 +2,7 @@ namespace rx=rxcpp; namespace rxu=rxcpp::util; namespace rxs=rxcpp::sources; +namespace rxo=rxcpp::operators; namespace rxsc=rxcpp::schedulers; #include "rxcpp/rx-test.hpp" @@ -315,6 +316,66 @@ SCENARIO("flat_map completes", "[flat_map][map][operators]"){ REQUIRE(required == actual); } } + + WHEN("streamed, each int is mapped to the strings"){ + + auto res = w.start( + [&]() { + return xs >> + rxo::flat_map( + [&](int){ + return ys;}, + [](int, std::string s){ + return s;}, + rx::identity_current_thread()) >> + // forget type to workaround lambda deduction bug on msvc 2013 + rxo::as_dynamic(); + } + ); + + THEN("the output contains strings repeated for each int"){ + auto required = rxu::to_vector({ + s_on.next(350, "foo"), + s_on.next(400, "bar"), + s_on.next(450, "baz"), + s_on.next(450, "foo"), + s_on.next(500, "qux"), + s_on.next(500, "bar"), + s_on.next(550, "baz"), + s_on.next(550, "foo"), + s_on.next(600, "qux"), + s_on.next(600, "bar"), + s_on.next(650, "baz"), + s_on.next(650, "foo"), + s_on.next(700, "qux"), + s_on.next(700, "bar"), + s_on.next(750, "baz"), + s_on.next(800, "qux"), + s_on.completed(850) + }); + auto actual = res.get_observer().messages(); + REQUIRE(required == actual); + } + + THEN("there was one subscription and one unsubscription to the ints"){ + auto required = rxu::to_vector({ + i_on.subscribe(200, 700) + }); + auto actual = xs.subscriptions(); + REQUIRE(required == actual); + } + + THEN("there were four subscription and unsubscription to the strings"){ + auto required = rxu::to_vector({ + s_on.subscribe(300, 550), + s_on.subscribe(400, 650), + s_on.subscribe(500, 750), + s_on.subscribe(600, 850) + }); + auto actual = ys.subscriptions(); + REQUIRE(required == actual); + } + } } } -- GitLab From 2be2cf92acb6483a88e368a0a7deb5c0b292ab3b Mon Sep 17 00:00:00 2001 From: ben Date: Tue, 17 Feb 2015 16:00:14 +0800 Subject: [PATCH 467/782] Fix Issue #93: Don't return a reference to a local variable in extract_list_front --- Rx/v2/src/rxcpp/rx-util.hpp | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 172720c..7b014a4 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -593,24 +593,11 @@ struct list_not_empty { }; struct extract_list_front { - // Clang optimisation loses moved list.front() value after list.pop_front(), so optimization must be switched off. template -#if defined(__clang__) && defined(__linux__) - // Clang on Linux has an attribute to forbid optimization - __attribute__((optnone)) -#endif - auto operator()(std::list& list) const - -> decltype(std::move(list.front())) { -#if defined(__clang__) && !defined(__linux__) - // Clang on OSX doesn't support the attribute - volatile auto val = std::move(list.front()); - list.pop_front(); - return std::move(const_cast(val)); -#else + T operator()(std::list& list) const { auto val = std::move(list.front()); list.pop_front(); - return std::move(val); -#endif + return val; } }; -- GitLab From 2e8e8903d6e33f7447313fccf98883f9991b83ce Mon Sep 17 00:00:00 2001 From: ben Date: Tue, 17 Feb 2015 19:36:20 +0800 Subject: [PATCH 468/782] Unnecessary semicolons are nnecessary --- Rx/v2/src/rxcpp/rx-observable.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index 5f15ef6..d1e60fc 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -867,7 +867,7 @@ public: template observable_type operator()(const Source& src, Coordination cn, ObservableN... on) const { return observable_type(operator_type(std::move(cn), rxu::pack(), std::make_tuple(src, std::move(on)...))); - }; + } }; template @@ -879,7 +879,7 @@ public: template observable_type operator()(const Source& src, Coordination cn, T0 t0, ObservableN... on) const { return observable_type(operator_type(std::move(cn), std::move(t0), std::make_tuple(src, std::move(on)...))); - }; + } }; template @@ -915,7 +915,7 @@ public: template observable_type operator()(const Source& src, Selector sel, ObservableN... on) const { return observable_type(operator_type(identity_current_thread(), std::move(sel), std::make_tuple(src, std::move(on)...))); - }; + } }; template @@ -927,7 +927,7 @@ public: template observable_type operator()(const Source& src, ObservableN... on) const { return observable_type(operator_type(identity_current_thread(), rxu::pack(), std::make_tuple(src, std::move(on)...))); - }; + } }; /// combine_latest -> @@ -951,7 +951,7 @@ public: template observable_type operator()(const Source& src, Coordination cn, ObservableN... on) const { return observable_type(operator_type(std::move(cn), rxu::pack(), std::make_tuple(src, std::move(on)...))); - }; + } }; template @@ -963,7 +963,7 @@ public: template observable_type operator()(const Source& src, Coordination cn, T0 t0, ObservableN... on) const { return observable_type(operator_type(std::move(cn), std::move(t0), std::make_tuple(src, std::move(on)...))); - }; + } }; template @@ -999,7 +999,7 @@ public: template observable_type operator()(const Source& src, Selector sel, ObservableN... on) const { return observable_type(operator_type(identity_current_thread(), std::move(sel), std::make_tuple(src, std::move(on)...))); - }; + } }; template @@ -1011,7 +1011,7 @@ public: template observable_type operator()(const Source& src, ObservableN... on) const { return observable_type(operator_type(identity_current_thread(), rxu::pack(), std::make_tuple(src, std::move(on)...))); - }; + } }; /// zip -> -- GitLab From 14b0164c5a6ecda8777476f6c27af3bbab1ebd33 Mon Sep 17 00:00:00 2001 From: BenPope Date: Wed, 18 Feb 2015 00:48:16 +0800 Subject: [PATCH 469/782] Use type aliases or: How I learned to love the closing chevron --- Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp | 16 ++-- .../rxcpp/operators/rx-buffer_time_count.hpp | 16 ++-- .../src/rxcpp/operators/rx-combine_latest.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 22 +++--- .../rxcpp/operators/rx-connect_forever.hpp | 8 +- .../operators/rx-distinct_until_changed.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-filter.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-finally.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 22 +++--- Rx/v2/src/rxcpp/operators/rx-group_by.hpp | 20 ++--- Rx/v2/src/rxcpp/operators/rx-lift.hpp | 14 ++-- Rx/v2/src/rxcpp/operators/rx-map.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-multicast.hpp | 10 +-- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-pairwise.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-publish.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 30 ++++---- Rx/v2/src/rxcpp/operators/rx-ref_count.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-repeat.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-retry.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-scan.hpp | 18 ++--- Rx/v2/src/rxcpp/operators/rx-skip.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-skip_until.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-start_with.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-subscribe.hpp | 4 +- Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp | 12 +-- .../src/rxcpp/operators/rx-switch_on_next.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-take.hpp | 12 +-- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-window.hpp | 8 +- Rx/v2/src/rxcpp/operators/rx-window_time.hpp | 16 ++-- .../rxcpp/operators/rx-window_time_count.hpp | 16 ++-- Rx/v2/src/rxcpp/operators/rx-zip.hpp | 16 ++-- Rx/v2/src/rxcpp/rx-connectable_observable.hpp | 4 +- Rx/v2/src/rxcpp/rx-coordination.hpp | 2 +- Rx/v2/src/rxcpp/rx-grouped_observable.hpp | 10 +-- Rx/v2/src/rxcpp/rx-notification.hpp | 2 +- Rx/v2/src/rxcpp/rx-observable.hpp | 74 +++++++++---------- Rx/v2/src/rxcpp/rx-observer.hpp | 16 ++-- Rx/v2/src/rxcpp/rx-operators.hpp | 2 +- Rx/v2/src/rxcpp/rx-predef.hpp | 24 +++--- Rx/v2/src/rxcpp/rx-scheduler.hpp | 2 +- Rx/v2/src/rxcpp/rx-sources.hpp | 2 +- Rx/v2/src/rxcpp/rx-subscriber.hpp | 2 +- Rx/v2/src/rxcpp/rx-subscription.hpp | 8 +- Rx/v2/src/rxcpp/rx-util.hpp | 9 ++- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 8 +- Rx/v2/src/rxcpp/sources/rx-create.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-defer.hpp | 10 +-- Rx/v2/src/rxcpp/sources/rx-error.hpp | 10 +-- Rx/v2/src/rxcpp/sources/rx-interval.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-iterate.hpp | 22 +++--- Rx/v2/src/rxcpp/sources/rx-range.hpp | 2 +- Rx/v2/src/rxcpp/sources/rx-scope.hpp | 12 +-- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 2 +- 58 files changed, 357 insertions(+), 354 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp index 56507d4..b729311 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp @@ -17,7 +17,7 @@ namespace detail { template struct buffer_count { - typedef typename std::decay::type source_value_type; + typedef rxu::decay_t source_value_type; struct buffer_count_values { buffer_count_values(int c, int s) @@ -41,7 +41,7 @@ struct buffer_count { typedef buffer_count_observer this_type; typedef std::vector value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; mutable int cursor; @@ -105,8 +105,8 @@ public: buffer_count_factory(int c, int s) : count(c), skip(s) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(buffer_count::type::value_type>(count, skip))) { - return source.template lift::type::value_type>>(buffer_count::type::value_type>(count, skip)); + -> decltype(source.template lift>>>(buffer_count>>(count, skip))) { + return source.template lift>>>(buffer_count>>(count, skip)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp index dac1302..5948347 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -19,10 +19,10 @@ struct buffer_with_time static_assert(std::is_convertible::value, "Duration parameter must convert to rxsc::scheduler::clock_type::duration"); static_assert(is_coordination::value, "Coordination parameter must satisfy the requirements for a Coordination"); - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay::type duration_type; + typedef rxu::decay_t duration_type; struct buffer_with_time_values { @@ -48,7 +48,7 @@ struct buffer_with_time { typedef buffer_with_time_observer this_type; typedef std::vector value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; struct buffer_with_time_subscriber_values : public buffer_with_time_values @@ -131,8 +131,8 @@ struct buffer_with_time template class buffer_with_time_factory { - typedef typename std::decay::type duration_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t duration_type; + typedef rxu::decay_t coordination_type; duration_type period; duration_type skip; @@ -141,8 +141,8 @@ public: buffer_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift::type::value_type>>(buffer_with_time::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift>>>(buffer_with_time>, Duration, Coordination>(period, skip, coordination))) { + return source.template lift>>>(buffer_with_time>, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp index ea4d608..87b6c2a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp @@ -19,10 +19,10 @@ struct buffer_with_time_or_count static_assert(std::is_convertible::value, "Duration parameter must convert to rxsc::scheduler::clock_type::duration"); static_assert(is_coordination::value, "Coordination parameter must satisfy the requirements for a Coordination"); - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay::type duration_type; + typedef rxu::decay_t duration_type; struct buffer_with_time_or_count_values { @@ -48,7 +48,7 @@ struct buffer_with_time_or_count { typedef buffer_with_time_or_count_observer this_type; typedef std::vector value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; struct buffer_with_time_or_count_subscriber_values : public buffer_with_time_or_count_values @@ -127,8 +127,8 @@ struct buffer_with_time_or_count template class buffer_with_time_or_count_factory { - typedef typename std::decay::type duration_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t duration_type; + typedef rxu::decay_t coordination_type; duration_type period; duration_type skip; @@ -137,8 +137,8 @@ public: buffer_with_time_or_count_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(buffer_with_time_or_count::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift::type::value_type>>(buffer_with_time_or_count::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift>>>(buffer_with_time_or_count>, Duration, Coordination>(period, skip, coordination))) { + return source.template lift>>>(buffer_with_time_or_count>, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index 3128217..3513dd0 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -19,8 +19,8 @@ struct combine_latest_traits { typedef std::tuple tuple_source_type; typedef std::tuple...> tuple_source_value_type; - typedef typename std::decay::type selector_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t selector_type; + typedef rxu::decay_t coordination_type; struct tag_not_valid {}; template @@ -34,7 +34,7 @@ struct combine_latest_traits { }; template -struct combine_latest : public operator_base::value_type> +struct combine_latest : public operator_base>> { typedef combine_latest this_type; @@ -179,8 +179,8 @@ struct combine_latest : public operator_base class combine_latest_factory { - typedef typename std::decay::type coordination_type; - typedef typename std::decay::type selector_type; + typedef rxu::decay_t coordination_type; + typedef rxu::decay_t selector_type; typedef std::tuple tuple_source_type; coordination_type coordination; @@ -189,9 +189,9 @@ class combine_latest_factory template auto make(std::tuple source) - -> observable::value_type, combine_latest> { - return observable::value_type, combine_latest>( - combine_latest(coordination, selector, std::move(source))); + -> observable>, combine_latest> { + return observable>, combine_latest>( + combine_latest(coordination, selector, std::move(source))); } public: combine_latest_factory(coordination_type sf, selector_type s, ObservableN... on) diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index 2afe974..01f023d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -15,13 +15,13 @@ namespace detail { template struct concat - : public operator_base::type::value_type> + : public operator_base>> { typedef concat this_type; - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type source_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; @@ -184,7 +184,7 @@ struct concat template class concat_factory { - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; coordination_type coordination; public: @@ -195,9 +195,9 @@ public: template auto operator()(Observable source) - -> observable::value_type, concat> { - return observable::value_type, concat>( - concat(std::move(source), coordination)); + -> observable, Observable, Coordination>>, concat, Observable, Coordination>> { + return observable, Observable, Coordination>>, concat, Observable, Coordination>>( + concat, Observable, Coordination>(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index e5ea951..72280e8 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -15,10 +15,10 @@ namespace detail { template struct concat_traits { - typedef typename std::decay::type source_type; - typedef typename std::decay::type collection_selector_type; - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t collection_selector_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t coordination_type; typedef typename source_type::value_type source_value_type; @@ -50,7 +50,7 @@ struct concat_traits { template struct concat_map - : public operator_base::value_type> + : public operator_base>> { typedef concat_map this_type; typedef concat_traits traits; @@ -241,9 +241,9 @@ private: template class concat_map_factory { - typedef typename std::decay::type collection_selector_type; - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t collection_selector_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t coordination_type; collection_selector_type selectorCollection; result_selector_type selectorResult; @@ -258,9 +258,9 @@ public: template auto operator()(Observable&& source) - -> observable::value_type, concat_map> { - return observable::value_type, concat_map>( - concat_map(std::forward(source), selectorCollection, selectorResult, coordination)); + -> observable>, concat_map> { + return observable>, concat_map>( + concat_map(std::forward(source), selectorCollection, selectorResult, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp index b38aa08..7713c2c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp @@ -16,7 +16,7 @@ namespace detail { template struct connect_forever : public operator_base { - typedef typename std::decay::type source_type; + typedef rxu::decay_t source_type; source_type source; @@ -38,9 +38,9 @@ public: connect_forever_factory() {} template auto operator()(Observable&& source) - -> observable::type::value_type, connect_forever::type::value_type, Observable>> { - return observable::type::value_type, connect_forever::type::value_type, Observable>>( - connect_forever::type::value_type, Observable>(std::forward(source))); + -> observable>, connect_forever>, Observable>> { + return observable>, connect_forever>, Observable>>( + connect_forever>, Observable>(std::forward(source))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp index 910edda..d43c03f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp @@ -16,14 +16,14 @@ namespace detail { template struct distinct_until_changed { - typedef typename std::decay::type source_value_type; + typedef rxu::decay_t source_value_type; template struct distinct_until_changed_observer { typedef distinct_until_changed_observer this_type; typedef source_value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; mutable rxu::detail::maybe remembered; @@ -62,8 +62,8 @@ class distinct_until_changed_factory public: template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>(distinct_until_changed::type>::value_type)) { - return source.template lift::type::value_type>(distinct_until_changed::type>::value_type); + -> decltype(source.template lift>>(distinct_until_changed>::value_type)) { + return source.template lift>>(distinct_until_changed>::value_type); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index 775bc16..f5aba00 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -16,8 +16,8 @@ namespace detail { template struct filter { - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type test_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t test_type; test_type test; filter(test_type t) @@ -30,7 +30,7 @@ struct filter { typedef filter_observer this_type; typedef source_value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; test_type test; @@ -73,14 +73,14 @@ struct filter template class filter_factory { - typedef typename std::decay::type test_type; + typedef rxu::decay_t test_type; test_type predicate; public: filter_factory(test_type p) : predicate(std::move(p)) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>(filter::type::value_type, test_type>(predicate))) { - return source.template lift::type::value_type>(filter::type::value_type, test_type>(predicate)); + -> decltype(source.template lift>>(filter>, test_type>(predicate))) { + return source.template lift>>(filter>, test_type>(predicate)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-finally.hpp b/Rx/v2/src/rxcpp/operators/rx-finally.hpp index 6e2b7ad..cd45d75 100644 --- a/Rx/v2/src/rxcpp/operators/rx-finally.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-finally.hpp @@ -16,8 +16,8 @@ namespace detail { template struct finally { - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type last_call_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t last_call_type; last_call_type last_call; finally(last_call_type lc) @@ -30,7 +30,7 @@ struct finally { typedef finally_observer this_type; typedef source_value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; @@ -70,14 +70,14 @@ struct finally template class finally_factory { - typedef typename std::decay::type last_call_type; + typedef rxu::decay_t last_call_type; last_call_type last_call; public: finally_factory(last_call_type lc) : last_call(std::move(lc)) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>(filter::type::value_type, last_call_type>(last_call))) { - return source.template lift::type::value_type>(filter::type::value_type, last_call_type>(last_call)); + -> decltype(source.template lift>>(filter>, last_call_type>(last_call))) { + return source.template lift>>(filter>, last_call_type>(last_call)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index f50ed43..afe6ae7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -15,10 +15,10 @@ namespace detail { template struct flat_map_traits { - typedef typename std::decay::type source_type; - typedef typename std::decay::type collection_selector_type; - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t collection_selector_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t coordination_type; typedef typename source_type::value_type source_value_type; @@ -48,7 +48,7 @@ struct flat_map_traits { template struct flat_map - : public operator_base::value_type> + : public operator_base>> { typedef flat_map this_type; typedef flat_map_traits traits; @@ -224,9 +224,9 @@ struct flat_map template class flat_map_factory { - typedef typename std::decay::type collection_selector_type; - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t collection_selector_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t coordination_type; collection_selector_type selectorCollection; result_selector_type selectorResult; @@ -241,9 +241,9 @@ public: template auto operator()(Observable&& source) - -> observable::value_type, flat_map> { - return observable::value_type, flat_map>( - flat_map(std::forward(source), selectorCollection, selectorResult, coordination)); + -> observable>, flat_map> { + return observable>, flat_map>( + flat_map(std::forward(source), selectorCollection, selectorResult, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp index 5ef609b..8afb4b9 100644 --- a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp @@ -16,7 +16,7 @@ namespace detail { template struct is_group_by_selector_for { - typedef typename std::decay::type selector_type; + typedef rxu::decay_t selector_type; typedef T source_value_type; struct tag_not_valid {}; @@ -33,10 +33,10 @@ template::type source_type; - typedef typename std::decay::type key_selector_type; - typedef typename std::decay::type marble_selector_type; - typedef typename std::decay::type predicate_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t key_selector_type; + typedef rxu::decay_t marble_selector_type; + typedef rxu::decay_t predicate_type; static_assert(is_group_by_selector_for::value, "group_by KeySelector must be a function with the signature key_type(source_value_type)"); @@ -110,7 +110,7 @@ struct group_by { typedef group_by_observer this_type; typedef typename traits_type::grouped_observable_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; @@ -174,9 +174,9 @@ struct group_by template class group_by_factory { - typedef typename std::decay::type key_selector_type; - typedef typename std::decay::type marble_selector_type; - typedef typename std::decay::type predicate_type; + typedef rxu::decay_t key_selector_type; + typedef rxu::decay_t marble_selector_type; + typedef rxu::decay_t predicate_type; key_selector_type keySelector; marble_selector_type marbleSelector; predicate_type predicate; @@ -190,7 +190,7 @@ public: template struct group_by_factory_traits { - typedef typename Observable::value_type value_type; + typedef rxu::value_type_t value_type; typedef detail::group_by_traits traits_type; typedef detail::group_by group_by_type; }; diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index 58fa4d6..4e95cb2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -20,8 +20,8 @@ struct is_lift_function_for { template static tag_not_valid check(...); - typedef typename std::decay::type for_type; - typedef typename std::decay::type func_type; + typedef rxu::decay_t for_type; + typedef rxu::decay_t func_type; typedef decltype(check(0)) detail_result; static const bool value = is_subscriber::value && is_subscriber::value && std::is_convertible::type>::value; }; @@ -35,9 +35,9 @@ namespace detail { template struct lift_traits { - typedef typename std::decay::type result_value_type; - typedef typename std::decay::type source_operator_type; - typedef typename std::decay::type operator_type; + typedef rxu::decay_t result_value_type; + typedef rxu::decay_t source_operator_type; + typedef rxu::decay_t operator_type; typedef typename source_operator_type::value_type source_value_type; @@ -70,7 +70,7 @@ struct lift_operator : public operator_base class lift_factory { - typedef typename std::decay::type operator_type; + typedef rxu::decay_t operator_type; operator_type chain; public: lift_factory(operator_type op) : chain(std::move(op)) {} @@ -78,7 +78,7 @@ public: auto operator()(const Observable& source) -> decltype(source.template lift(chain)) { return source.template lift(chain); - static_assert(rxcpp::detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); + static_assert(rxcpp::detail::is_lift_function_for, subscriber, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 662cf95..855f8eb 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -17,8 +17,8 @@ namespace detail { template struct map { - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type select_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t select_type; typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; select_type selector; @@ -32,7 +32,7 @@ struct map { typedef map_observer this_type; typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; select_type selector; @@ -75,14 +75,14 @@ struct map template class map_factory { - typedef typename std::decay::type select_type; + typedef rxu::decay_t select_type; select_type selector; public: map_factory(select_type s) : selector(std::move(s)) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector))) { - return source.template lift::type::value_type, select_type>::value_type>(map::type::value_type, select_type>(selector)); + -> decltype(source.template lift>, select_type>>>(map>, select_type>(selector))) { + return source.template lift>, select_type>>>(map>, select_type>(selector)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 9faa862..04d5a41 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -15,20 +15,20 @@ namespace detail { template struct merge - : public operator_base::type::value_type> + : public operator_base>> { //static_assert(is_observable::value, "merge requires an observable"); //static_assert(is_observable::value, "merge requires an observable that contains observables"); typedef merge this_type; - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type source_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t source_type; typedef typename source_type::source_operator_type source_operator_type; typedef typename source_value_type::value_type value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values @@ -172,7 +172,7 @@ struct merge template class merge_factory { - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; coordination_type coordination; public: @@ -183,9 +183,9 @@ public: template auto operator()(Observable source) - -> observable::value_type, merge> { - return observable::value_type, merge>( - merge(std::move(source), coordination)); + -> observable, Observable, Coordination>>, merge, Observable, Coordination>> { + return observable, Observable, Coordination>>, merge, Observable, Coordination>>( + merge, Observable, Coordination>(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp index 966bfa3..e970bfe 100644 --- a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp @@ -16,8 +16,8 @@ namespace detail { template struct multicast : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type subject_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t subject_type; struct multicast_state : public std::enable_shared_from_this { @@ -76,9 +76,9 @@ public: } template auto operator()(Observable&& source) - -> connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject>> { - return connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject>>( - multicast::type::value_type, Observable, Subject>(std::forward(source), caster)); + -> connectable_observable>, multicast>, Observable, Subject>> { + return connectable_observable>, multicast>, Observable, Subject>>( + multicast>, Observable, Subject>(std::forward(source), caster)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 4d89044..8f52473 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -16,9 +16,9 @@ namespace detail { template struct observe_on { - typedef typename std::decay::type source_value_type; + typedef rxu::decay_t source_value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; coordination_type coordination; @@ -34,7 +34,7 @@ struct observe_on typedef observe_on_observer this_type; typedef observer_base base_type; typedef source_value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; typedef rxn::notification notification_type; @@ -184,14 +184,14 @@ struct observe_on template class observe_on_factory { - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; coordination_type coordination; public: observe_on_factory(coordination_type cn) : coordination(std::move(cn)) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>(observe_on::type::value_type, coordination_type>(coordination))) { - return source.template lift::type::value_type>(observe_on::type::value_type, coordination_type>(coordination)); + -> decltype(source.template lift>>(observe_on>, coordination_type>(coordination))) { + return source.template lift>>(observe_on>, coordination_type>(coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp b/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp index 582aba5..8531e8c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp @@ -16,7 +16,7 @@ namespace detail { template struct pairwise { - typedef typename std::decay::type source_value_type; + typedef rxu::decay_t source_value_type; typedef std::tuple value_type; template @@ -24,7 +24,7 @@ struct pairwise { typedef pairwise_observer this_type; typedef std::tuple value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; mutable rxu::detail::maybe remembered; @@ -67,8 +67,8 @@ class pairwise_factory public: template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>::value_type>(pairwise::type::value_type>())) { - return source.template lift::type::value_type>::value_type>(pairwise::type::value_type>()); + -> decltype(source.template lift>>>>(pairwise>>())) { + return source.template lift>>>>(pairwise>>()); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-publish.hpp b/Rx/v2/src/rxcpp/operators/rx-publish.hpp index 34de51a..3589cc9 100644 --- a/Rx/v2/src/rxcpp/operators/rx-publish.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-publish.hpp @@ -20,10 +20,10 @@ public: publish_factory() {} template auto operator()(Observable&& source) - -> connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject::type::value_type>>> { - return connectable_observable::type::value_type, multicast::type::value_type, Observable, Subject::type::value_type>>>( - multicast::type::value_type, Observable, Subject::type::value_type>>( - std::forward(source), Subject::type::value_type>())); + -> connectable_observable>, multicast>, Observable, Subject>>>> { + return connectable_observable>, multicast>, Observable, Subject>>>>( + multicast>, Observable, Subject>>>( + std::forward(source), Subject>>())); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 9d3d39b..1c740bc 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -16,8 +16,8 @@ namespace detail { template struct is_accumulate_function_for { - typedef typename std::decay::type accumulator_type; - typedef typename std::decay::type seed_type; + typedef rxu::decay_t accumulator_type; + typedef rxu::decay_t seed_type; typedef T source_value_type; struct tag_not_valid {}; @@ -33,8 +33,8 @@ struct is_accumulate_function_for { template struct is_result_function_for { - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type seed_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t seed_type; struct tag_not_valid {}; @@ -50,10 +50,10 @@ struct is_result_function_for { template struct reduce_traits { - typedef typename std::decay::type source_type; - typedef typename std::decay::type accumulator_type; - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type seed_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t accumulator_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t seed_type; typedef T source_value_type; @@ -65,7 +65,7 @@ struct reduce_traits }; template -struct reduce : public operator_base::value_type> +struct reduce : public operator_base>> { typedef reduce this_type; typedef reduce_traits traits; @@ -164,9 +164,9 @@ private: template class reduce_factory { - typedef typename std::decay::type accumulator_type; - typedef typename std::decay::type result_selector_type; - typedef typename std::decay::type seed_type; + typedef rxu::decay_t accumulator_type; + typedef rxu::decay_t result_selector_type; + typedef rxu::decay_t seed_type; accumulator_type accumulator; result_selector_type result_selector; @@ -180,9 +180,9 @@ public: } template auto operator()(const Observable& source) - -> observable> { - return observable>( - reduce(source.source_operator, accumulator, result_selector, seed)); + -> observable, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>> { + return observable, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>>( + reduce, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>(source.source_operator, accumulator, result_selector, seed)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp index 41e4bd9..2d41ef2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -16,7 +16,7 @@ namespace detail { template struct ref_count : public operator_base { - typedef typename std::decay::type source_type; + typedef rxu::decay_t source_type; struct ref_count_state : public std::enable_shared_from_this { @@ -65,9 +65,9 @@ public: ref_count_factory() {} template auto operator()(Observable&& source) - -> observable::type::value_type, ref_count::type::value_type, Observable>> { - return observable::type::value_type, ref_count::type::value_type, Observable>>( - ref_count::type::value_type, Observable>(std::forward(source))); + -> observable>, ref_count>, Observable>> { + return observable>, ref_count>, Observable>>( + ref_count>, Observable>(std::forward(source))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp index 91f59b8..b9038ac 100644 --- a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp @@ -16,8 +16,8 @@ namespace detail { template struct repeat : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type count_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t count_type; struct values { values(source_type s, count_type t) @@ -94,16 +94,16 @@ struct repeat : public operator_base template class repeat_factory { - typedef typename std::decay::type count_type; + typedef rxu::decay_t count_type; count_type count; public: repeat_factory(count_type t) : count(std::move(t)) {} template auto operator()(Observable&& source) - -> observable::type::value_type, repeat::type::value_type, Observable, count_type>> { - return observable::type::value_type, repeat::type::value_type, Observable, count_type>>( - repeat::type::value_type, Observable, count_type>(std::forward(source), count)); + -> observable>, repeat>, Observable, count_type>> { + return observable>, repeat>, Observable, count_type>>( + repeat>, Observable, count_type>(std::forward(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-retry.hpp b/Rx/v2/src/rxcpp/operators/rx-retry.hpp index 112edef..acfa20b 100644 --- a/Rx/v2/src/rxcpp/operators/rx-retry.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-retry.hpp @@ -15,8 +15,8 @@ namespace rxcpp { template struct retry : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type count_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t count_type; struct values { values(source_type s, count_type t) : source(std::move(s)) @@ -90,16 +90,16 @@ namespace rxcpp { template class retry_factory { - typedef typename std::decay::type count_type; + typedef rxu::decay_t count_type; count_type count; public: retry_factory(count_type t) : count(std::move(t)) {} template auto operator()(Observable&& source) - -> observable::type::value_type, retry::type::value_type, Observable, count_type>> { - return observable::type::value_type, retry::type::value_type, Observable, count_type>>( - retry::type::value_type, Observable, count_type>(std::forward(source), count)); + -> observable>, retry>, Observable, count_type>> { + return observable>, retry>, Observable, count_type>>( + retry>, Observable, count_type>(std::forward(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-scan.hpp b/Rx/v2/src/rxcpp/operators/rx-scan.hpp index 1b45437..7f2a314 100644 --- a/Rx/v2/src/rxcpp/operators/rx-scan.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-scan.hpp @@ -14,11 +14,11 @@ namespace operators { namespace detail { template -struct scan : public operator_base::type> +struct scan : public operator_base> { - typedef typename std::decay::type source_type; - typedef typename std::decay::type accumulator_type; - typedef typename std::decay::type seed_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t accumulator_type; + typedef rxu::decay_t seed_type; struct scan_initial_type { @@ -88,8 +88,8 @@ struct scan : public operator_base::type> template class scan_factory { - typedef typename std::decay::type accumulator_type; - typedef typename std::decay::type seed_type; + typedef rxu::decay_t accumulator_type; + typedef rxu::decay_t seed_type; accumulator_type accumulator; seed_type seed; @@ -101,9 +101,9 @@ public: } template auto operator()(Observable&& source) - -> observable::type, scan::type::value_type, Observable, Accumulator, Seed>> { - return observable::type, scan::type::value_type, Observable, Accumulator, Seed>>( - scan::type::value_type, Observable, Accumulator, Seed>(std::forward(source), accumulator, seed)); + -> observable, scan>, Observable, Accumulator, Seed>> { + return observable, scan>, Observable, Accumulator, Seed>>( + scan>, Observable, Accumulator, Seed>(std::forward(source), accumulator, seed)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-skip.hpp b/Rx/v2/src/rxcpp/operators/rx-skip.hpp index 3fa7209..94ebe5a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip.hpp @@ -16,8 +16,8 @@ namespace detail { template struct skip : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type count_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t count_type; struct values { values(source_type s, count_type t) @@ -99,15 +99,15 @@ struct skip : public operator_base template class skip_factory { - typedef typename std::decay::type count_type; + typedef rxu::decay_t count_type; count_type count; public: skip_factory(count_type t) : count(std::move(t)) {} template auto operator()(Observable&& source) - -> observable::type::value_type, skip::type::value_type, Observable, count_type>> { - return observable::type::value_type, skip::type::value_type, Observable, count_type>>( - skip::type::value_type, Observable, count_type>(std::forward(source), count)); + -> observable>, skip>, Observable, count_type>> { + return observable>, skip>, Observable, count_type>>( + skip>, Observable, count_type>(std::forward(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp index 49441e4..4b4644f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp @@ -16,9 +16,9 @@ namespace detail { template struct skip_until : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type trigger_source_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t trigger_source_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values { @@ -164,8 +164,8 @@ struct skip_until : public operator_base template class skip_until_factory { - typedef typename std::decay::type trigger_source_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t trigger_source_type; + typedef rxu::decay_t coordination_type; trigger_source_type trigger_source; coordination_type coordination; @@ -177,9 +177,9 @@ public: } template auto operator()(Observable&& source) - -> observable::type::value_type, skip_until::type::value_type, Observable, trigger_source_type, Coordination>> { - return observable::type::value_type, skip_until::type::value_type, Observable, trigger_source_type, Coordination>>( - skip_until::type::value_type, Observable, trigger_source_type, Coordination>(std::forward(source), trigger_source, coordination)); + -> observable>, skip_until>, Observable, trigger_source_type, Coordination>> { + return observable>, skip_until>, Observable, trigger_source_type, Coordination>>( + skip_until>, Observable, trigger_source_type, Coordination>(std::forward(source), trigger_source, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-start_with.hpp b/Rx/v2/src/rxcpp/operators/rx-start_with.hpp index d605ceb..16e909f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-start_with.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-start_with.hpp @@ -13,8 +13,8 @@ namespace operators { template auto start_with(Observable o, Value0 v0, ValueN... vn) - -> decltype(rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o)) { - return rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o); + -> decltype(rxs::from(rxu::value_type_t(v0), rxu::value_type_t(vn)...).concat(o)) { + return rxs::from(rxu::value_type_t(v0), rxu::value_type_t(vn)...).concat(o); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp index cc25c1d..af74d2e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp @@ -77,8 +77,8 @@ class dynamic_factory public: template auto operator()(Observable&& source) - -> observable::type::value_type> { - return observable::type::value_type>(std::forward(source)); + -> observable>> { + return observable>>(std::forward(source)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp index c1adb2c..4142890 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp @@ -16,8 +16,8 @@ namespace detail { template struct subscribe_on : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct subscribe_on_values { @@ -110,7 +110,7 @@ private: template class subscribe_on_factory { - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; coordination_type coordination; public: @@ -120,9 +120,9 @@ public: } template auto operator()(Observable&& source) - -> observable::type::value_type, subscribe_on::type::value_type, Observable, Coordination>> { - return observable::type::value_type, subscribe_on::type::value_type, Observable, Coordination>>( - subscribe_on::type::value_type, Observable, Coordination>(std::forward(source), coordination)); + -> observable>, subscribe_on>, Observable, Coordination>> { + return observable>, subscribe_on>, Observable, Coordination>>( + subscribe_on>, Observable, Coordination>(std::forward(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp index 3403553..a3620b2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -15,22 +15,22 @@ namespace detail { template struct switch_on_next - : public operator_base::type::value_type> + : public operator_base>> { //static_assert(is_observable::value, "switch_on_next requires an observable"); //static_assert(is_observable::value, "switch_on_next requires an observable that contains observables"); typedef switch_on_next this_type; - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type source_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t source_type; typedef typename source_type::source_operator_type source_operator_type; typedef source_value_type collection_type; typedef typename collection_type::value_type collection_value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values @@ -183,7 +183,7 @@ struct switch_on_next template class switch_on_next_factory { - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; coordination_type coordination; public: @@ -194,9 +194,9 @@ public: template auto operator()(Observable source) - -> observable::value_type, switch_on_next> { - return observable::value_type, switch_on_next>( - switch_on_next(std::move(source), coordination)); + -> observable, Observable, Coordination>>, switch_on_next, Observable, Coordination>> { + return observable, Observable, Coordination>>, switch_on_next, Observable, Coordination>>( + switch_on_next, Observable, Coordination>(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index 5043385..182a20f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -16,8 +16,8 @@ namespace detail { template struct take : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type count_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t count_type; struct values { values(source_type s, count_type t) @@ -103,15 +103,15 @@ struct take : public operator_base template class take_factory { - typedef typename std::decay::type count_type; + typedef rxu::decay_t count_type; count_type count; public: take_factory(count_type t) : count(std::move(t)) {} template auto operator()(Observable&& source) - -> observable::type::value_type, take::type::value_type, Observable, count_type>> { - return observable::type::value_type, take::type::value_type, Observable, count_type>>( - take::type::value_type, Observable, count_type>(std::forward(source), count)); + -> observable>, take>, Observable, count_type>> { + return observable>, take>, Observable, count_type>>( + take>, Observable, count_type>(std::forward(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index b1fb8ff..e4109cd 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -16,9 +16,9 @@ namespace detail { template struct take_until : public operator_base { - typedef typename std::decay::type source_type; - typedef typename std::decay::type trigger_source_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t trigger_source_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values { @@ -162,8 +162,8 @@ struct take_until : public operator_base template class take_until_factory { - typedef typename std::decay::type trigger_source_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t trigger_source_type; + typedef rxu::decay_t coordination_type; trigger_source_type trigger_source; coordination_type coordination; @@ -175,9 +175,9 @@ public: } template auto operator()(Observable&& source) - -> observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, Coordination>> { - return observable::type::value_type, take_until::type::value_type, Observable, trigger_source_type, Coordination>>( - take_until::type::value_type, Observable, trigger_source_type, Coordination>(std::forward(source), trigger_source, coordination)); + -> observable>, take_until>, Observable, trigger_source_type, Coordination>> { + return observable>, take_until>, Observable, trigger_source_type, Coordination>>( + take_until>, Observable, trigger_source_type, Coordination>(std::forward(source), trigger_source, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window.hpp b/Rx/v2/src/rxcpp/operators/rx-window.hpp index c2bf220..57d04f0 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window.hpp @@ -16,7 +16,7 @@ namespace detail { template struct window { - typedef typename std::decay::type source_value_type; + typedef rxu::decay_t source_value_type; struct window_values { window_values(int c, int s) @@ -41,7 +41,7 @@ struct window typedef window_observer this_type; typedef observer_base> base_type; typedef typename base_type::value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; dest_type dest; mutable int cursor; @@ -107,8 +107,8 @@ public: window_factory(int c, int s) : count(c), skip(s) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(window::type::value_type>(count, skip))) { - return source.template lift::type::value_type>>(window::type::value_type>(count, skip)); + -> decltype(source.template lift>>>(window>>(count, skip))) { + return source.template lift>>>(window>>(count, skip)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp index aca16de..734520e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -16,10 +16,10 @@ namespace detail { template struct window_with_time { - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay::type duration_type; + typedef rxu::decay_t duration_type; struct window_with_time_values { @@ -46,7 +46,7 @@ struct window_with_time typedef window_with_time_observer this_type; typedef observer_base> base_type; typedef typename base_type::value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; struct window_with_time_subscriber_values : public window_with_time_values @@ -128,8 +128,8 @@ struct window_with_time template class window_with_time_factory { - typedef typename std::decay::type duration_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t duration_type; + typedef rxu::decay_t coordination_type; duration_type period; duration_type skip; @@ -138,8 +138,8 @@ public: window_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(window_with_time::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift::type::value_type>>(window_with_time::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift>>>(window_with_time>, Duration, Coordination>(period, skip, coordination))) { + return source.template lift>>>(window_with_time>, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp index a3e45f4..fa50a57 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp @@ -16,10 +16,10 @@ namespace detail { template struct window_with_time_or_count { - typedef typename std::decay::type source_value_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t source_value_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay::type duration_type; + typedef rxu::decay_t duration_type; struct window_with_time_or_count_values { @@ -46,7 +46,7 @@ struct window_with_time_or_count typedef window_with_time_or_count_observer this_type; typedef observer_base> base_type; typedef typename base_type::value_type value_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef observer observer_type; struct window_with_time_or_count_subscriber_values : public window_with_time_or_count_values @@ -133,8 +133,8 @@ struct window_with_time_or_count template class window_with_time_or_count_factory { - typedef typename std::decay::type duration_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t duration_type; + typedef rxu::decay_t coordination_type; duration_type period; int count; @@ -143,8 +143,8 @@ public: window_with_time_or_count_factory(duration_type p, int n, coordination_type c) : period(p), count(n), coordination(c) {} template auto operator()(Observable&& source) - -> decltype(source.template lift::type::value_type>>(window_with_time_or_count::type::value_type, Duration, Coordination>(period, count, coordination))) { - return source.template lift::type::value_type>>(window_with_time_or_count::type::value_type, Duration, Coordination>(period, count, coordination)); + -> decltype(source.template lift>>>(window_with_time_or_count>, Duration, Coordination>(period, count, coordination))) { + return source.template lift>>>(window_with_time_or_count>, Duration, Coordination>(period, count, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-zip.hpp b/Rx/v2/src/rxcpp/operators/rx-zip.hpp index a391c48..19e03f6 100644 --- a/Rx/v2/src/rxcpp/operators/rx-zip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-zip.hpp @@ -18,8 +18,8 @@ struct zip_traits { typedef std::tuple tuple_source_type; typedef std::tuple...> tuple_source_values_type; - typedef typename std::decay::type selector_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t selector_type; + typedef rxu::decay_t coordination_type; struct tag_not_valid {}; template @@ -33,7 +33,7 @@ struct zip_traits { }; template -struct zip : public operator_base::value_type> +struct zip : public operator_base>> { typedef zip this_type; @@ -171,8 +171,8 @@ struct zip : public operator_base class zip_factory { - typedef typename std::decay::type coordination_type; - typedef typename std::decay::type selector_type; + typedef rxu::decay_t coordination_type; + typedef rxu::decay_t selector_type; typedef std::tuple tuple_source_type; coordination_type coordination; @@ -181,9 +181,9 @@ class zip_factory template auto make(std::tuple source) - -> observable::value_type, zip> { - return observable::value_type, zip>( - zip(coordination, selector, std::move(source))); + -> observable>, zip> { + return observable>, zip>( + zip(coordination, selector, std::move(source))); } public: zip_factory(coordination_type sf, selector_type s, ObservableN... on) diff --git a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp index 731d844..b650b09 100644 --- a/Rx/v2/src/rxcpp/rx-connectable_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-connectable_observable.hpp @@ -51,7 +51,7 @@ class dynamic_connectable_observable template void construct(SO&& source, rxs::tag_source&&) { - auto so = std::make_shared::type>(std::forward(source)); + auto so = std::make_shared>(std::forward(source)); state->on_connect = [so](composite_subscription cs) mutable { so->on_connect(std::move(cs)); }; @@ -102,7 +102,7 @@ class connectable_observable { typedef connectable_observable this_type; typedef observable base_type; - typedef typename std::decay::type source_operator_type; + typedef rxu::decay_t source_operator_type; static_assert(detail::has_on_connect::value, "inner must have on_connect method void(composite_subscription)"); diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index 23c5405..0b95db3 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -193,7 +193,7 @@ class serialize_one_worker : public coordination_base struct serialize_observer { typedef serialize_observer this_type; - typedef typename std::decay::type dest_type; + typedef rxu::decay_t dest_type; typedef typename dest_type::value_type value_type; typedef observer observer_type; dest_type dest; diff --git a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp index 84deef9..8c81400 100644 --- a/Rx/v2/src/rxcpp/rx-grouped_observable.hpp +++ b/Rx/v2/src/rxcpp/rx-grouped_observable.hpp @@ -21,7 +21,7 @@ struct has_on_get_key_for static not_void check(...); typedef decltype(check(0)) detail_result; - static const bool value = std::is_same::type>::value; + static const bool value = std::is_same>::value; }; } @@ -31,7 +31,7 @@ class dynamic_grouped_observable : public dynamic_observable { public: - typedef typename std::decay::type key_type; + typedef rxu::decay_t key_type; typedef tag_dynamic_grouped_observable dynamic_observable_tag; private: @@ -59,7 +59,7 @@ private: template void construct(SO&& source, const rxs::tag_source&) { - auto so = std::make_shared::type>(std::forward(source)); + auto so = std::make_shared>(std::forward(source)); state->on_get_key = [so]() mutable { return so->on_get_key(); }; @@ -117,12 +117,12 @@ class grouped_observable { typedef grouped_observable this_type; typedef observable base_type; - typedef typename std::decay::type source_operator_type; + typedef rxu::decay_t source_operator_type; static_assert(detail::has_on_get_key_for::value, "inner must have on_get_key method key_type()"); public: - typedef typename std::decay::type key_type; + typedef rxu::decay_t key_type; typedef tag_grouped_observable observable_tag; grouped_observable() diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index 0ba09ea..f8cafbb 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -224,7 +224,7 @@ private: template type operator()(Exception&& e) const { return make_on_error(typename std::conditional< - std::is_same::type, std::exception_ptr>::value, + std::is_same, std::exception_ptr>::value, exception_ptr_tag, exception_tag>::type(), std::forward(e)); } diff --git a/Rx/v2/src/rxcpp/rx-observable.hpp b/Rx/v2/src/rxcpp/rx-observable.hpp index d1e60fc..bb0e275 100644 --- a/Rx/v2/src/rxcpp/rx-observable.hpp +++ b/Rx/v2/src/rxcpp/rx-observable.hpp @@ -26,8 +26,8 @@ struct is_operator_factory_for template static not_void check(...); - typedef typename std::decay::type source_type; - typedef typename std::decay::type function_type; + typedef rxu::decay_t source_type; + typedef rxu::decay_t function_type; typedef decltype(check(0)) detail_result; static const bool value = !std::is_same::value && is_observable::value; @@ -42,7 +42,7 @@ struct has_on_subscribe_for template static not_void check(...); - typedef decltype(check::type, T>(0)) detail_result; + typedef decltype(check, T>(0)) detail_result; static const bool value = std::is_same::value; }; @@ -66,7 +66,7 @@ class dynamic_observable template void construct(SO&& source, rxs::tag_source&&) { - typename std::decay::type so = std::forward(source); + rxu::decay_t so = std::forward(source); state->on_subscribe = [so](subscriber o) mutable { so.on_subscribe(std::move(o)); }; @@ -234,7 +234,7 @@ class blocking_observable } public: - typedef typename std::decay::type observable_type; + typedef rxu::decay_t observable_type; observable_type source; ~blocking_observable() { @@ -296,7 +296,7 @@ class observable typedef observable this_type; public: - typedef typename std::decay::type source_operator_type; + typedef rxu::decay_t source_operator_type; mutable source_operator_type source_operator; private: @@ -311,7 +311,7 @@ private: auto detail_subscribe(Subscriber o) const -> composite_subscription { - typedef typename std::decay::type subscriber_type; + typedef rxu::decay_t subscriber_type; static_assert(is_subscriber::value, "subscribe must be passed a subscriber"); static_assert(std::is_same::value && std::is_convertible::value, "the value types in the sequence must match or be convertible"); @@ -426,9 +426,9 @@ public: /// template auto lift(Operator&& op) const - -> observable::value_type, rxo::detail::lift_operator> { - return observable::value_type, rxo::detail::lift_operator>( - rxo::detail::lift_operator(source_operator, std::forward(op))); + -> observable>, rxo::detail::lift_operator> { + return observable>, rxo::detail::lift_operator>( + rxo::detail::lift_operator(source_operator, std::forward(op))); static_assert(detail::is_lift_function_for, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber)"); } @@ -440,9 +440,9 @@ public: template auto lift_if(Operator&& op) const -> typename std::enable_if, Operator>::value, - observable::value_type, rxo::detail::lift_operator>>::type { - return observable::value_type, rxo::detail::lift_operator>( - rxo::detail::lift_operator(source_operator, std::forward(op))); + observable>, rxo::detail::lift_operator>>::type { + return observable>, rxo::detail::lift_operator>( + rxo::detail::lift_operator(source_operator, std::forward(op))); } /// /// takes any function that will take a subscriber for this observable and produce a subscriber. @@ -494,8 +494,8 @@ public: /// template auto map(Selector s) const - -> decltype(EXPLICIT_THIS lift::value_type>(rxo::detail::map(std::move(s)))) { - return lift::value_type>(rxo::detail::map(std::move(s))); + -> decltype(EXPLICIT_THIS lift>>(rxo::detail::map(std::move(s)))) { + return lift>>(rxo::detail::map(std::move(s))); } /// distinct_until_changed -> @@ -747,9 +747,9 @@ public: /// template auto flat_map(CollectionSelector&& s, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::flat_map> { - return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_current_thread())); + -> observable>, rxo::detail::flat_map> { + return observable>, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), identity_current_thread())); } /// flat_map (AKA SelectMany) -> @@ -759,9 +759,9 @@ public: /// template auto flat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) const - -> observable::value_type, rxo::detail::flat_map> { - return observable::value_type, rxo::detail::flat_map>( - rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); + -> observable>, rxo::detail::flat_map> { + return observable>, rxo::detail::flat_map>( + rxo::detail::flat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } template @@ -838,9 +838,9 @@ public: /// template auto concat_map(CollectionSelector&& s, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::concat_map> { - return observable::value_type, rxo::detail::concat_map>( - rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_current_thread())); + -> observable>, rxo::detail::concat_map> { + return observable>, rxo::detail::concat_map>( + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), identity_current_thread())); } /// concat_map -> @@ -850,9 +850,9 @@ public: /// template auto concat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) const - -> observable::value_type, rxo::detail::concat_map> { - return observable::value_type, rxo::detail::concat_map>( - rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); + -> observable>, rxo::detail::concat_map> { + return observable>, rxo::detail::concat_map>( + rxo::detail::concat_map(*this, std::forward(s), std::forward(rs), std::forward(sf))); } template @@ -1082,9 +1082,9 @@ public: /// template auto subscribe_on(Coordination cn) const - -> observable::value_type, rxo::detail::subscribe_on> { - return observable::value_type, rxo::detail::subscribe_on>( - rxo::detail::subscribe_on(*this, std::move(cn))); + -> observable>, rxo::detail::subscribe_on> { + return observable>, rxo::detail::subscribe_on>( + rxo::detail::subscribe_on(*this, std::move(cn))); } /// observe_on -> @@ -1101,9 +1101,9 @@ public: /// template auto reduce(Seed seed, Accumulator&& a, ResultSelector&& rs) const - -> observable::value_type, rxo::detail::reduce> { - return observable::value_type, rxo::detail::reduce>( - rxo::detail::reduce(source_operator, std::forward(a), std::forward(rs), seed)); + -> observable>, rxo::detail::reduce> { + return observable>, rxo::detail::reduce>( + rxo::detail::reduce(source_operator, std::forward(a), std::forward(rs), seed)); } template @@ -1315,8 +1315,8 @@ public: /// take values pairwise from the observable /// auto pairwise() const - -> decltype(EXPLICIT_THIS lift::value_type>(rxo::detail::pairwise())) { - return lift::value_type>(rxo::detail::pairwise()); + -> decltype(EXPLICIT_THIS lift>>(rxo::detail::pairwise())) { + return lift>>(rxo::detail::pairwise()); } }; @@ -1473,8 +1473,8 @@ public: } template static auto start_with(Observable o, Value0 v0, ValueN... vn) - -> decltype(rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o)) { - return rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o); + -> decltype(rxs::from(rxu::value_type_t(v0), rxu::value_type_t(vn)...).concat(o)) { + return rxs::from(rxu::value_type_t(v0), rxu::value_type_t(vn)...).concat(o); } template static auto scope(ResourceFactory rf, ObservableFactory of) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index 6fad944..da93bff 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -44,7 +44,7 @@ struct is_on_next_of template static not_void check(...); - typedef decltype(check::type>(0)) detail_result; + typedef decltype(check>(0)) detail_result; static const bool value = std::is_same::value; }; @@ -57,7 +57,7 @@ struct is_on_error template static not_void check(...); - static const bool value = std::is_same::type>(0)), void>::value; + static const bool value = std::is_same>(0)), void>::value; }; template @@ -69,7 +69,7 @@ struct is_on_completed template static not_void check(...); - static const bool value = std::is_same::type>(0)), void>::value; + static const bool value = std::is_same>(0)), void>::value; }; } @@ -79,9 +79,9 @@ class static_observer { public: typedef static_observer this_type; - typedef typename std::decay::type on_next_t; - typedef typename std::decay::type on_error_t; - typedef typename std::decay::type on_completed_t; + typedef rxu::decay_t on_next_t; + typedef rxu::decay_t on_error_t; + typedef rxu::decay_t on_completed_t; private: on_next_t onnext; @@ -224,7 +224,7 @@ template class observer : public observer_base { typedef observer this_type; - typedef typename std::decay::type inner_t; + typedef rxu::decay_t inner_t; inner_t inner; @@ -387,7 +387,7 @@ template struct maybe_from_result { typedef decltype((*(F*)nullptr)()) decl_result_type; - typedef typename std::decay::type result_type; + typedef rxu::decay_t result_type; typedef rxu::maybe type; }; diff --git a/Rx/v2/src/rxcpp/rx-operators.hpp b/Rx/v2/src/rxcpp/rx-operators.hpp index 5e4e042..9d9aec8 100644 --- a/Rx/v2/src/rxcpp/rx-operators.hpp +++ b/Rx/v2/src/rxcpp/rx-operators.hpp @@ -26,7 +26,7 @@ class is_operator template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_operator*>::value; + static const bool value = std::is_convertible>(0)), tag_operator*>::value; }; } diff --git a/Rx/v2/src/rxcpp/rx-predef.hpp b/Rx/v2/src/rxcpp/rx-predef.hpp index 634b73f..ebb20ea 100644 --- a/Rx/v2/src/rxcpp/rx-predef.hpp +++ b/Rx/v2/src/rxcpp/rx-predef.hpp @@ -37,7 +37,7 @@ class is_worker template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_worker*>::value; + static const bool value = std::is_convertible>(0)), tag_worker*>::value; }; struct tag_scheduler {}; @@ -50,7 +50,7 @@ class is_scheduler template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_scheduler*>::value; + static const bool value = std::is_convertible>(0)), tag_scheduler*>::value; }; struct tag_schedulable {}; @@ -63,7 +63,7 @@ class is_schedulable template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_schedulable*>::value; + static const bool value = std::is_convertible>(0)), tag_schedulable*>::value; }; @@ -82,7 +82,7 @@ class is_observer template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_observer*>::value; + static const bool value = std::is_convertible>(0)), tag_observer*>::value; }; struct tag_dynamic_observer {}; @@ -95,7 +95,7 @@ class is_dynamic_observer template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_dynamic_observer*>::value; + static const bool value = std::is_convertible>(0)), tag_dynamic_observer*>::value; }; struct tag_subscriber {}; @@ -108,7 +108,7 @@ class is_subscriber template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_subscriber*>::value; + static const bool value = std::is_convertible>(0)), tag_subscriber*>::value; }; struct tag_dynamic_observable {}; @@ -121,7 +121,7 @@ class is_dynamic_observable template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_dynamic_observable*>::value; + static const bool value = std::is_convertible>(0)), tag_dynamic_observable*>::value; }; template @@ -153,7 +153,7 @@ class is_observable template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_observable>::value; + static const bool value = std::is_convertible>(0)), tag_observable>::value; }; struct tag_dynamic_connectable_observable : public tag_dynamic_observable {}; @@ -167,7 +167,7 @@ class is_dynamic_connectable_observable template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_dynamic_connectable_observable*>::value; + static const bool value = std::is_convertible>(0)), tag_dynamic_connectable_observable*>::value; }; template @@ -187,7 +187,7 @@ class is_connectable_observable template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_connectable_observable>::value; + static const bool value = std::is_convertible>(0)), tag_connectable_observable>::value; }; struct tag_dynamic_grouped_observable : public tag_dynamic_observable {}; @@ -201,7 +201,7 @@ class is_dynamic_grouped_observable template static not_void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_dynamic_grouped_observable*>::value; + static const bool value = std::is_convertible>(0)), tag_dynamic_grouped_observable*>::value; }; template @@ -224,7 +224,7 @@ class is_grouped_observable template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_grouped_observable>::value; + static const bool value = std::is_convertible>(0)), tag_grouped_observable>::value; }; // diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index f91e66c..bd490fa 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -180,7 +180,7 @@ struct is_action_function template static not_void check(...); - static const bool value = std::is_same::type>(0)), void>::value; + static const bool value = std::is_same>(0)), void>::value; }; } diff --git a/Rx/v2/src/rxcpp/rx-sources.hpp b/Rx/v2/src/rxcpp/rx-sources.hpp index 25d40ec..7afcf73 100644 --- a/Rx/v2/src/rxcpp/rx-sources.hpp +++ b/Rx/v2/src/rxcpp/rx-sources.hpp @@ -27,7 +27,7 @@ class is_source template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_source*>::value; + static const bool value = std::is_convertible>(0)), tag_source*>::value; }; } diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index 0092637..ad8e5b2 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -21,7 +21,7 @@ class subscriber : public subscriber_base static_assert(!is_subscriber::value, "not allowed to nest subscribers"); static_assert(is_observer::value, "subscriber must contain an observer"); typedef subscriber this_type; - typedef typename std::decay::type observer_type; + typedef rxu::decay_t observer_type; composite_subscription lifetime; observer_type destination; diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 6263a1f..a5fce21 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -20,7 +20,7 @@ struct is_unsubscribe_function template static not_void check(...); - static const bool value = std::is_same::type>(0)), void>::value; + static const bool value = std::is_same>(0)), void>::value; }; } @@ -35,13 +35,13 @@ class is_subscription template static void check(...); public: - static const bool value = std::is_convertible::type>(0)), tag_subscription*>::value; + static const bool value = std::is_convertible>(0)), tag_subscription*>::value; }; template class static_subscription { - typedef typename std::decay::type unsubscribe_call_type; + typedef rxu::decay_t unsubscribe_call_type; unsubscribe_call_type unsubscribe_call; static_subscription() { @@ -86,7 +86,7 @@ private: template struct subscription_state : public base_subscription_state { - typedef typename std::decay::type inner_t; + typedef rxu::decay_t inner_t; subscription_state(inner_t i) : base_subscription_state(true) , inner(std::move(i)) diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index 7b014a4..b2493f3 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -40,6 +40,9 @@ namespace rxcpp { namespace util { +template using value_type_t = typename T::value_type; +template using decay_t = typename std::decay::type; + template std::vector to_vector(const T (&arr) [size]) { return std::vector(std::begin(arr), std::end(arr)); @@ -125,8 +128,8 @@ template struct value_type_from : public std::false_type {typedef types_checked type;}; template -struct value_type_from::type> - : public std::true_type {typedef typename T::value_type type;}; +struct value_type_from>::type> + : public std::true_type {typedef value_type_t type;}; @@ -281,7 +284,7 @@ struct defer_value_type struct tag_not_valid {typedef void type; static const bool value = false;}; typedef Deferred::type...> resolved_type; template - static auto check(int) -> tag_valid; + static auto check(int) -> tag_valid>; template static tag_not_valid check(...); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 331bea9..24a88d9 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -347,7 +347,7 @@ struct is_create_source_function template static not_void check(...); - static const bool value = is_observable::type>(0))>::value; + static const bool value = is_observable>(0))>::value; }; } @@ -512,21 +512,21 @@ public: auto start(F createSource, long created, long subscribed, long unsubscribed) const -> typename std::enable_if::value, start_traits>::type::subscriber_type { - return start::value_type>(std::move(createSource), created, subscribed, unsubscribed); + return start>>(std::move(createSource), created, subscribed, unsubscribed); } template auto start(F createSource, long unsubscribed) const -> typename std::enable_if::value, start_traits>::type::subscriber_type { - return start::value_type>(std::move(createSource), created_time, subscribed_time, unsubscribed); + return start>>(std::move(createSource), created_time, subscribed_time, unsubscribed); } template auto start(F createSource) const -> typename std::enable_if::value, start_traits>::type::subscriber_type { - return start::value_type>(std::move(createSource), created_time, subscribed_time, unsubscribed_time); + return start>>(std::move(createSource), created_time, subscribed_time, unsubscribed_time); } void start() const { diff --git a/Rx/v2/src/rxcpp/sources/rx-create.hpp b/Rx/v2/src/rxcpp/sources/rx-create.hpp index 2c50e98..ed27fea 100644 --- a/Rx/v2/src/rxcpp/sources/rx-create.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-create.hpp @@ -18,7 +18,7 @@ struct create : public source_base { typedef create this_type; - typedef typename std::decay::type on_subscribe_type; + typedef rxu::decay_t on_subscribe_type; on_subscribe_type on_subscribe_function; diff --git a/Rx/v2/src/rxcpp/sources/rx-defer.hpp b/Rx/v2/src/rxcpp/sources/rx-defer.hpp index 5aef7ef..3afff64 100644 --- a/Rx/v2/src/rxcpp/sources/rx-defer.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-defer.hpp @@ -16,13 +16,13 @@ namespace detail { template struct defer_traits { - typedef typename std::decay::type observable_factory_type; + typedef rxu::decay_t observable_factory_type; typedef decltype((*(observable_factory_type*)nullptr)()) collection_type; typedef typename collection_type::value_type value_type; }; template -struct defer : public source_base::value_type> +struct defer : public source_base>> { typedef defer this_type; typedef defer_traits traits; @@ -54,9 +54,9 @@ struct defer : public source_base::valu template auto defer(ObservableFactory of) - -> observable::value_type, detail::defer> { - return observable::value_type, detail::defer>( - detail::defer(std::move(of))); + -> observable>, detail::defer> { + return observable>, detail::defer>( + detail::defer(std::move(of))); } } diff --git a/Rx/v2/src/rxcpp/sources/rx-error.hpp b/Rx/v2/src/rxcpp/sources/rx-error.hpp index 5014c7c..3f3e07b 100644 --- a/Rx/v2/src/rxcpp/sources/rx-error.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-error.hpp @@ -18,7 +18,7 @@ struct error : public source_base { typedef error this_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; @@ -88,13 +88,13 @@ auto make_error(throw_instance_tag&&, E e, Coordination cn) template auto error(E e) - -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_immediate())) { - return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_immediate()); + -> decltype(detail::make_error(typename std::conditional>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_immediate())) { + return detail::make_error(typename std::conditional>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), identity_immediate()); } template auto error(E e, Coordination cn) - -> decltype(detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(cn))) { - return detail::make_error(typename std::conditional::type>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(cn)); + -> decltype(detail::make_error(typename std::conditional>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(cn))) { + return detail::make_error(typename std::conditional>::value, detail::throw_ptr_tag, detail::throw_instance_tag>::type(), std::move(e), std::move(cn)); } } diff --git a/Rx/v2/src/rxcpp/sources/rx-interval.hpp b/Rx/v2/src/rxcpp/sources/rx-interval.hpp index dade61a..afd5dac 100644 --- a/Rx/v2/src/rxcpp/sources/rx-interval.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-interval.hpp @@ -18,7 +18,7 @@ struct interval : public source_base { typedef interval this_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct interval_initial_type diff --git a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp index c78d0a2..be98c0c 100644 --- a/Rx/v2/src/rxcpp/sources/rx-iterate.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-iterate.hpp @@ -16,7 +16,7 @@ namespace detail { template struct is_iterable { - typedef typename std::decay::type collection_type; + typedef rxu::decay_t collection_type; struct not_void {}; template @@ -30,18 +30,18 @@ struct is_iterable template struct iterate_traits { - typedef typename std::decay::type collection_type; + typedef rxu::decay_t collection_type; typedef decltype(std::begin(*(collection_type*)nullptr)) iterator_type; - typedef typename std::iterator_traits::value_type value_type; + typedef rxu::value_type_t> value_type; }; template -struct iterate : public source_base::value_type> +struct iterate : public source_base>> { typedef iterate this_type; typedef iterate_traits traits; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; typedef typename traits::collection_type collection_type; @@ -134,15 +134,15 @@ struct iterate : public source_base::value_t template auto iterate(Collection c) - -> observable::value_type, detail::iterate> { - return observable::value_type, detail::iterate>( - detail::iterate(std::move(c), identity_immediate())); + -> observable>, detail::iterate> { + return observable>, detail::iterate>( + detail::iterate(std::move(c), identity_immediate())); } template auto iterate(Collection c, Coordination cn) - -> observable::value_type, detail::iterate> { - return observable::value_type, detail::iterate>( - detail::iterate(std::move(c), std::move(cn))); + -> observable>, detail::iterate> { + return observable>, detail::iterate>( + detail::iterate(std::move(c), std::move(cn))); } template diff --git a/Rx/v2/src/rxcpp/sources/rx-range.hpp b/Rx/v2/src/rxcpp/sources/rx-range.hpp index 4af7c24..0be3ae4 100644 --- a/Rx/v2/src/rxcpp/sources/rx-range.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-range.hpp @@ -16,7 +16,7 @@ namespace detail { template struct range : public source_base { - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct range_state_type diff --git a/Rx/v2/src/rxcpp/sources/rx-scope.hpp b/Rx/v2/src/rxcpp/sources/rx-scope.hpp index 1b7a26d..8105ef4 100644 --- a/Rx/v2/src/rxcpp/sources/rx-scope.hpp +++ b/Rx/v2/src/rxcpp/sources/rx-scope.hpp @@ -16,8 +16,8 @@ namespace detail { template struct scope_traits { - typedef typename std::decay::type resource_factory_type; - typedef typename std::decay::type observable_factory_type; + typedef rxu::decay_t resource_factory_type; + typedef rxu::decay_t observable_factory_type; typedef decltype((*(resource_factory_type*)nullptr)()) resource_type; typedef decltype((*(observable_factory_type*)nullptr)(resource_type())) collection_type; typedef typename collection_type::value_type value_type; @@ -26,7 +26,7 @@ struct scope_traits }; template -struct scope : public source_base::value_type> +struct scope : public source_base>> { typedef scope_traits traits; typedef typename traits::resource_factory_type resource_factory_type; @@ -93,9 +93,9 @@ struct scope : public source_base auto scope(ResourceFactory rf, ObservableFactory of) - -> observable::value_type, detail::scope> { - return observable::value_type, detail::scope>( - detail::scope(std::move(rf), std::move(of))); + -> observable>, detail::scope> { + return observable>, detail::scope>( + detail::scope(std::move(rf), std::move(of))); } } diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 564f564..25f79cf 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -19,7 +19,7 @@ class synchronize_observer : public detail::multicast_observer typedef synchronize_observer this_type; typedef detail::multicast_observer base_type; - typedef typename std::decay::type coordination_type; + typedef rxu::decay_t coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; typedef typename coordinator_type::template get>::type output_type; -- GitLab From ff6617f703d7eba1db496d31aa1f51fb09077868 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Feb 2015 14:56:50 -0800 Subject: [PATCH 470/782] vc2015 issue is forcing a shift away from on_exception usage --- .../src/rxcpp/operators/rx-combine_latest.hpp | 13 ++------ Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 9 ++--- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 33 ++++--------------- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 17 +++------- Rx/v2/src/rxcpp/operators/rx-reduce.hpp | 18 +++------- Rx/v2/src/rxcpp/operators/rx-scan.hpp | 8 +---- .../src/rxcpp/operators/rx-switch_on_next.hpp | 17 ++-------- Rx/v2/src/rxcpp/operators/rx-zip.hpp | 11 ++----- Rx/v2/src/rxcpp/rx-subscriber.hpp | 11 +++++-- 9 files changed, 34 insertions(+), 103 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index 3513dd0..d051f83 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -93,7 +93,6 @@ struct combine_latest : public operator_base(state->latest); if (value.empty()) { @@ -103,15 +102,9 @@ struct combine_latest : public operator_basevaluesSet == sizeof... (ObservableN)) { - auto selectedResult = on_exception( - [&](){ - return rxu::apply(rxu::surely(state->latest), state->selector); - }, - state->out); - if (selectedResult.empty()) { - return; - } - state->out.on_next(selectedResult.get()); + auto values = rxu::surely(state->latest); + auto selectedResult = rxu::apply(values, state->selector); + state->out.on_next(selectedResult); } }, // on_error diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 72280e8..4d9fb5c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -143,13 +143,8 @@ struct concat_map collectionLifetime, // on_next [state, st](collection_value_type ct) { - auto selectedResult = on_exception( - [&](){return state->selectResult(st, std::move(ct));}, - state->out); - if (selectedResult.empty()) { - return; - } - state->out.on_next(std::move(*selectedResult)); + auto selectedResult = state->selectResult(st, std::move(ct)); + state->out.on_next(std::move(selectedResult)); }, // on_error [state](std::exception_ptr e) { diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index afe6ae7..7cce410 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -136,12 +136,6 @@ struct flat_map outercs, // on_next [state](source_value_type st) { - auto selectedCollection = on_exception( - [&](){return state->selectCollection(st);}, - state->out); - if (selectedCollection.empty()) { - return; - } composite_subscription innercs; @@ -153,12 +147,8 @@ struct flat_map state->out.remove(innercstoken); })); - auto selectedSource = on_exception( - [&](){return state->coordinator.in(selectedCollection.get());}, - state->out); - if (selectedSource.empty()) { - return; - } + auto selectedCollection = state->selectCollection(st); + auto selectedSource = state->coordinator.in(selectedCollection); ++state->pendingCompletions; // this subscribe does not share the source subscription @@ -168,13 +158,8 @@ struct flat_map innercs, // on_next [state, st](collection_value_type ct) { - auto selectedResult = on_exception( - [&](){return state->selectResult(st, std::move(ct));}, - state->out); - if (selectedResult.empty()) { - return; - } - state->out.on_next(std::move(*selectedResult)); + auto selectedResult = state->selectResult(st, std::move(ct)); + state->out.on_next(std::move(selectedResult)); }, // on_error [state](std::exception_ptr e) { @@ -188,14 +173,8 @@ struct flat_map } ); - auto selectedSinkInner = on_exception( - [&](){return state->coordinator.out(sinkInner);}, - state->out); - if (selectedSinkInner.empty()) { - return; - } - - selectedSource->subscribe(std::move(selectedSinkInner.get())); + auto selectedSinkInner = state->coordinator.out(sinkInner); + selectedSource.subscribe(std::move(selectedSinkInner)); }, // on_error [state](std::exception_ptr e) { diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 04d5a41..6e5dd2f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -112,12 +112,7 @@ struct merge state->out.remove(innercstoken); })); - auto selectedSource = on_exception( - [&](){return state->coordinator.in(st);}, - state->out); - if (selectedSource.empty()) { - return; - } + auto selectedSource = state->coordinator.in(st); ++state->pendingCompletions; // this subscribe does not share the source subscription @@ -140,13 +135,9 @@ struct merge } } ); - auto selectedSinkInner = on_exception( - [&](){return state->coordinator.out(sinkInner);}, - state->out); - if (selectedSinkInner.empty()) { - return; - } - selectedSource->subscribe(std::move(selectedSinkInner.get())); + + auto selectedSinkInner = state->coordinator.out(sinkInner); + selectedSource.subscribe(std::move(selectedSinkInner)); }, // on_error [state](std::exception_ptr e) { diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 1c740bc..221b163 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -132,13 +132,8 @@ struct reduce : public operator_baseout, // on_next [state](T t) { - auto next = on_exception( - [&](){return state->accumulator(state->current, t);}, - state->out); - if (next.empty()) { - return; - } - state->current = next.get(); + auto next = state->accumulator(state->current, t); + state->current = next; }, // on_error [state](std::exception_ptr e) { @@ -146,13 +141,8 @@ struct reduce : public operator_baseresult_selector(state->current);}, - state->out); - if (result.empty()) { - return; - } - state->out.on_next(result.get()); + auto result = state->result_selector(state->current); + state->out.on_next(result); state->out.on_completed(); } ); diff --git a/Rx/v2/src/rxcpp/operators/rx-scan.hpp b/Rx/v2/src/rxcpp/operators/rx-scan.hpp index 7f2a314..24d2886 100644 --- a/Rx/v2/src/rxcpp/operators/rx-scan.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-scan.hpp @@ -64,13 +64,7 @@ struct scan : public operator_base> state->out, // on_next [state](T t) { - auto result = on_exception( - [&](){return state->accumulator(state->result, t);}, - state->out); - if (result.empty()) { - return; - } - state->result = result.get(); + state->result = state->accumulator(state->result, t); state->out.on_next(state->result); }, // on_error diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp index a3620b2..91a20a7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -118,12 +118,7 @@ struct switch_on_next --state->pendingCompletions; })); - auto selectedSource = on_exception( - [&](){return state->coordinator.in(st);}, - state->out); - if (selectedSource.empty()) { - return; - } + auto selectedSource = state->coordinator.in(st); // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue @@ -146,15 +141,9 @@ struct switch_on_next } ); - auto selectedSinkInner = on_exception( - [&](){return state->coordinator.out(sinkInner);}, - state->out); - if (selectedSinkInner.empty()) { - return; - } - + auto selectedSinkInner = state->coordinator.out(sinkInner); ++state->pendingCompletions; - selectedSource->subscribe(std::move(selectedSinkInner.get())); + selectedSource.subscribe(std::move(selectedSinkInner)); }, // on_error [state](std::exception_ptr e) { diff --git a/Rx/v2/src/rxcpp/operators/rx-zip.hpp b/Rx/v2/src/rxcpp/operators/rx-zip.hpp index 19e03f6..d62073d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-zip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-zip.hpp @@ -95,15 +95,8 @@ struct zip : public operator_base(state->pending); values.push_back(st); if (rxu::apply_to_each(state->pending, rxu::list_not_empty(), rxu::all_values_true())) { - auto selectedResult = on_exception( - [&](){ - return rxu::apply_to_each(state->pending, rxu::extract_list_front(), state->selector); - }, - state->out); - if (selectedResult.empty()) { - return; - } - state->out.on_next(selectedResult.get()); + auto selectedResult = rxu::apply_to_each(state->pending, rxu::extract_list_front(), state->selector); + state->out.on_next(selectedResult); } }, // on_error diff --git a/Rx/v2/src/rxcpp/rx-subscriber.hpp b/Rx/v2/src/rxcpp/rx-subscriber.hpp index ad8e5b2..6e6d10a 100644 --- a/Rx/v2/src/rxcpp/rx-subscriber.hpp +++ b/Rx/v2/src/rxcpp/rx-subscriber.hpp @@ -44,8 +44,15 @@ class subscriber : public subscriber_base template void operator()(U u) { trace_activity().on_next_enter(*that, u); - that->destination.on_next(std::move(u)); - do_unsubscribe = false; + try { + that->destination.on_next(std::move(u)); + do_unsubscribe = false; + } catch(...) { + auto ex = std::current_exception(); + trace_activity().on_error_enter(*that, ex); + that->destination.on_error(std::move(ex)); + trace_activity().on_error_return(*that); + } } const this_type* that; bool do_unsubscribe; -- GitLab From ba5fb591d035a151ed58a6083217614e234d39cd Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Feb 2015 15:02:46 -0800 Subject: [PATCH 471/782] vs2015 warns of name hiding --- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 2 -- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 4 ++-- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 1 - 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 8f52473..82235f4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -57,7 +57,6 @@ struct observe_on mutable queue_type queue; mutable queue_type drain_queue; composite_subscription lifetime; - rxsc::worker processor; mutable typename mode::type current; coordinator_type coordinator; dest_type destination; @@ -119,7 +118,6 @@ struct observe_on [&](){return coordinator.act(drain);}, destination); if (selectedDrain.empty()) { - std::unique_lock guard(lock); current = mode::Errored; using std::swap; queue_type expired; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 24a88d9..0d65d5f 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -404,8 +404,8 @@ public: struct subscribe_factory { - rxn::subscription operator()(long subscribe, long unsubscribe) const { - return rxn::subscription(subscribe, unsubscribe); + rxn::subscription operator()(long subscribeAt, long unsubscribeAt) const { + return rxn::subscription(subscribeAt, unsubscribeAt); } }; static const subscribe_factory subscribe; diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 25f79cf..4e167bc 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -43,7 +43,6 @@ class synchronize_observer : public detail::multicast_observer mutable std::condition_variable wake; mutable queue_type queue; composite_subscription lifetime; - rxsc::worker processor; mutable typename mode::type current; coordinator_type coordinator; output_type destination; -- GitLab From 13b6df5513d509b5bddd03cc806f476c358b1db6 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Feb 2015 15:06:38 -0800 Subject: [PATCH 472/782] vs2015 size mismatch warning --- Rx/v2/test/operators/zip.1.cpp | 4 ++-- Rx/v2/test/operators/zip.2.cpp | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Rx/v2/test/operators/zip.1.cpp b/Rx/v2/test/operators/zip.1.cpp index a1313c6..4ebb165 100644 --- a/Rx/v2/test/operators/zip.1.cpp +++ b/Rx/v2/test/operators/zip.1.cpp @@ -290,10 +290,10 @@ SCENARIO("zip empty N", "[zip][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const size_t N = 16; + const int N = 16; std::vector> e; - for (size_t i = 0; i < N; ++i) { + for (int i = 0; i < N; ++i) { e.push_back( sc.make_hot_observable({ on.next(150, 1), diff --git a/Rx/v2/test/operators/zip.2.cpp b/Rx/v2/test/operators/zip.2.cpp index 38eaec7..d56cb83 100644 --- a/Rx/v2/test/operators/zip.2.cpp +++ b/Rx/v2/test/operators/zip.2.cpp @@ -322,12 +322,12 @@ SCENARIO("zip selector throws N", "[zip][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const size_t N = 16; + const int N = 16; std::runtime_error ex("zip on_error from source"); std::vector> e; - for (size_t i = 0; i < N; ++i) { + for (int i = 0; i < N; ++i) { e.push_back( sc.make_hot_observable({ on.next(210 + 10 * i, 1), @@ -380,10 +380,10 @@ SCENARIO("zip typical N", "[zip][join][operators]"){ auto w = sc.create_worker(); const rxsc::test::messages on; - const size_t N = 16; + const int N = 16; std::vector> o; - for (size_t i = 0; i < N; ++i) { + for (int i = 0; i < N; ++i) { o.push_back( sc.make_hot_observable({ on.next(150, 1), -- GitLab From 93f04f7a7b8a2ab6fafb72debd37d3342054bd8e Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Feb 2015 15:13:45 -0800 Subject: [PATCH 473/782] rework pi tests and fix io sideeffects --- Rx/v2/test/operators/group_by.cpp | 72 ++++++++++++++++++++----------- 1 file changed, 47 insertions(+), 25 deletions(-) diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index 674c54a..8c80fe3 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -25,25 +25,37 @@ SCENARIO("range partitioned by group_by across hardware threads to derive pi", " // share an output thread across all the producer threads auto outputthread = rxcpp::observe_on_one_worker(rxcpp::observe_on_new_thread().create_coordinator().get_scheduler()); + struct work + { + int index; + int first; + int last; + }; + // use all available hardware threads - auto total = rxcpp::observable<>::range(0, 19). + auto total = rxcpp::observable<>::range(0, (2 * std::thread::hardware_concurrency()) - 1). + map( + [](int index){ + static const int chunk = 100000000 / (2 * std::thread::hardware_concurrency()); + int first = (chunk * index) + 1; + int last = chunk * (index + 1); + return work{index, first, last};} + ). group_by( - [](int i) -> int {return i % std::thread::hardware_concurrency();}, - [](int i){return i;}). + [](work w) -> int {return w.index % std::thread::hardware_concurrency();}, + [](work w){return w;}). map( - [=, &c](rxcpp::grouped_observable onproc) { + [=, &c](rxcpp::grouped_observable onproc) { auto key = onproc.get_key(); - // share a producer thread across all the ranges in this group + // share a producer thread across all the ranges in this group of chunks auto producerthread = rxcpp::observe_on_one_worker(rxcpp::observe_on_new_thread().create_coordinator().get_scheduler()); return onproc. map( - [=, &c](int index){ - static const int chunk = 1000000; - auto first = (chunk * index) + 1; - auto last = chunk * (index + 1); - std::cout << std::setw(3) << index << ": range - " << first << "-" << last << std::endl; + [=, &c](work w){ + std::stringstream message; + message << std::setw(3) << w.index << ": range - " << w.first << "-" << w.last; - return rxcpp::observable<>::range(first, last, producerthread). + return rxcpp::observable<>::range(w.first, w.last, producerthread). map(pi). sum(). // each thread maps and reduces its contribution to the answer map( @@ -52,6 +64,7 @@ SCENARIO("range partitioned by group_by across hardware threads to derive pi", " message << key << " on " << std::this_thread::get_id() << " - value: " << std::setprecision(16) << v; return std::make_tuple(message.str(), v); }). + start_with(std::make_tuple(message.str(), 0)). as_dynamic(); }). concat(). // only subscribe to one range at a time in this group. @@ -91,32 +104,41 @@ SCENARIO("range partitioned by dividing work across hardware threads to derive p using namespace std::chrono; auto start = steady_clock::now(); - // share an output thread across all the producer threads - auto outputthread = rxcpp::observe_on_one_worker(rxcpp::observe_on_new_thread().create_coordinator().get_scheduler()); + struct work + { + int index; + int first; + int last; + }; // use all available hardware threads - auto total = rxcpp::observable<>::range(0, std::thread::hardware_concurrency() - 1). + auto total = rxcpp::observable<>::range(0, (2 * std::thread::hardware_concurrency()) - 1). + map( + [](int index){ + static const int chunk = 100000000 / (2 * std::thread::hardware_concurrency()); + int first = (chunk * index) + 1; + int last = chunk * (index + 1); + return work{index, first, last}; + }). map( - [=, &c](int index){ - // partition equally across threads - static const int chunk = 20000000 / std::thread::hardware_concurrency(); - auto first = (chunk * index) + 1; - auto last = chunk * (index + 1); - std::cout << std::setw(3) << index << ": range - " << first << "-" << last << std::endl; - - return rxcpp::observable<>::range(first, last, rxcpp::observe_on_new_thread()). + [=, &c](work w){ + std::stringstream message; + message << std::setw(3) << w.index << ": range - " << w.first << "-" << w.last; + + // create a new thread for every chunk + return rxcpp::observable<>::range(w.first, w.last, rxcpp::observe_on_new_thread()). map(pi). sum(). // each thread maps and reduces its contribution to the answer map( [=](long double v){ std::stringstream message; - message << std::this_thread::get_id() << " - value: " << std::setprecision(16) << v; + message << w.index << " on " << std::this_thread::get_id() << " - value: " << std::setprecision(16) << v; return std::make_tuple(message.str(), v); }). + start_with(std::make_tuple(message.str(), 0)). as_dynamic(); }). - observe_on(outputthread). - merge(). + merge(rxcpp::observe_on_new_thread()). map(rxcpp::util::apply_to( [](std::string message, long double v){ std::cout << message << std::endl; -- GitLab From 20706a51e3d7ebfe390ff9653c3f3200af752fd0 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Feb 2015 15:17:41 -0800 Subject: [PATCH 474/782] update nuget description --- projects/nuget/rxcpp.autoconfig | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/projects/nuget/rxcpp.autoconfig b/projects/nuget/rxcpp.autoconfig index bb3b63e..25d1193 100644 --- a/projects/nuget/rxcpp.autoconfig +++ b/projects/nuget/rxcpp.autoconfig @@ -1,7 +1,7 @@ nuget { nuspec { id = rxcpp; - version : 1.0.2; + version : 2.1.1; title: Reactive Extensions for C++; authors: {Microsoft Open Technologies Inc.}; owners: {Microsoft Open Technologies Inc.}; @@ -10,10 +10,11 @@ nuget { iconUrl: "http://go.microsoft.com/fwlink/?LinkId=261274"; requireLicenseAcceptance:false; summary: "The Reactive Extensions (Rx) asynchronous programming library"; - description: @"The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and operators. Operators are the asynchronous form of standard library algorithms and they operate on Observables instead of iterators. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize the concurrency in the asynchronous data streams using Schedulers."; - releaseNotes: "This release has many new operators and schedulers. Also some preliminary support for MVVM in WinRT."; - copyright: Copyright 2013; - tags: { RxCpp, RxC++, Rx, Reactive, Observable, Functional, native}; + description: @"The Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and operators. Operators are the asynchronous form of standard library algorithms and they operate on Observables instead of iterators. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize the concurrency in the asynchronous data streams using Schedulers. + Compiles for gcc, clang and VisualStudio on Linux, OSX and Windows."; + releaseNotes: "bug fixes, blocking_observable, tracing hooks and new operators; subscribe_on/observe_on, repeat, skip, finally, group_by, window, retry, scope, start_with, first, last, count"; + copyright: Copyright 2014; + tags: { RxCpp, RxC++, Rx, Reactive, Observable, Functional, native, nativepackage}; }; files { @@ -21,8 +22,8 @@ nuget { #defines { SDK_RX = ..\..\; } - include: { "${SDK_RX}Rx\v2\src\**\*", "${SDK_RX}Ix\CPP\src\**\*" }; - docs: { ${SDK_RX}Readme.html, ${SDK_RX}AUTHORS.txt, ${SDK_RX}v2\license.txt }; + include: { "${SDK_RX}Rx\v2\src\**\*" }; + docs: { ${SDK_RX}AUTHORS.txt, ${SDK_RX}Rx\v2\license.txt, ${SDK_RX}Rx\v2\examples\**\* }; } targets { -- GitLab From 41b0d2338987741a5aab28a99adc0cc952e78a2b Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Feb 2015 22:34:53 -0800 Subject: [PATCH 475/782] travis ci changes --- .travis.yml | 24 ++++++++++------ Rx/v2/src/rxcpp/rx-observer.hpp | 6 ++-- projects/CMake/CMakeLists.txt | 16 +++++++---- projects/scripts/travis-install.sh | 44 ++++++++++++------------------ 4 files changed, 46 insertions(+), 44 deletions(-) diff --git a/.travis.yml b/.travis.yml index c7f1c83..e698adb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,9 +10,13 @@ compiler: - gcc env: - - BUILD_TYPE=Release + - CMAKE_BUILD_TYPE=RelWithDebInfo +# - CMAKE_BUILD_TYPE=Debug matrix: + allow_failures: + - compiler: clang + os: linux exclude: - compiler: gcc os: osx @@ -21,25 +25,27 @@ before_install: - sh projects/scripts/travis-install.sh install: - - export PATH=/usr/bin:$PATH + - $CXX --version + - /usr/local/bin/cmake --version - cd projects - - cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX - - cd build - - make -j2 - - cd ../.. + - /usr/local/bin/cmake -GUnix\ Makefiles -HCMake -Bbuild -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX + - cd .. script: - cd projects/build - - ./rxcppv2_test --success -r compact + - make -j2 - cd ../.. +#after_success: +# - projects/build/rxcppv2_test + branches: only: - master notifications: - recipients: - - kirk.shoop@microsoft.com email: + recipients: + - kirk.shoop@microsoft.com on_success: always on_failure: always diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index da93bff..bbc72e0 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -143,9 +143,9 @@ private: struct virtual_observer : public std::enable_shared_from_this { - virtual void on_next(T) const =0; - virtual void on_error(std::exception_ptr e) const =0; - virtual void on_completed() const =0; + virtual void on_next(T) const {}; + virtual void on_error(std::exception_ptr) const {}; + virtual void on_completed() const {}; }; template diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index a951c2d..a0b1e66 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -2,20 +2,24 @@ cmake_minimum_required(VERSION 2.8) project(rxcpp) -MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) - FIND_PACKAGE(Threads) -if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") +MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + MESSAGE( STATUS "using clang settings" ) add_compile_options( -Wall -Wextra -Werror ) - add_compile_options( -std=c++11 ) + add_compile_options( -std=c++11 -stdlib=libc++ ) add_compile_options( -ftemplate-depth=1024 ) # sometimes you just do what the compiler tells you -elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") +elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU") + MESSAGE( STATUS "using gnu settings" ) add_compile_options( -Wall -Wextra -Werror ) add_compile_options( -std=c++11 ) -elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") +elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + MESSAGE( STATUS "using msvc settings" ) add_compile_options( /W4 /WX ) add_compile_options( /wd4503 ) # truncated symbol + add_compile_options( /wd4702 ) # unreachable code + add_compile_options( /bigobj ) add_definitions( /DUNICODE /D_UNICODE ) # it is a new millenium endif() diff --git a/projects/scripts/travis-install.sh b/projects/scripts/travis-install.sh index 6712002..8f2ae7b 100755 --- a/projects/scripts/travis-install.sh +++ b/projects/scripts/travis-install.sh @@ -4,45 +4,37 @@ set -e #if OS is linux or is not set if [ "$TRAVIS_OS_NAME" = linux -o -z "$TRAVIS_OS_NAME" ]; then - wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key|sudo apt-key add - - sudo add-apt-repository -y 'deb http://llvm.org/apt/trusty/ llvm-toolchain-trusty main' - sudo add-apt-repository -y "deb http://us.archive.ubuntu.com/ubuntu/ trusty main universe" - sudo add-apt-repository -y ppa:28msec/utils # Recent cmake - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test # gcc-4.8 backport for clang +# wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key|sudo apt-key add - +# sudo add-apt-repository -y 'deb http://llvm.org/apt/trusty/ llvm-toolchain-trusty main' +# sudo add-apt-repository -y "deb http://us.archive.ubuntu.com/ubuntu/ trusty main universe" + sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test sudo apt-get clean -qq || echo "ignore clean failure" sudo apt-get update -qq || echo "ignore update failure" - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing cmake libssl-dev || echo "ignore install failure" - - if [ "$CC" = clang ]; then - sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing clang-3.6 || echo "ignore install failure" - - sudo update-alternatives --remove-all clang || echo "ignore remove failure" - sudo update-alternatives --remove-all clang++ || echo "ignore remove failure" - - sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.6 20 - sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.6 20 - - sudo update-alternatives --config clang - sudo update-alternatives --config clang++ - fi + wget http://www.cmake.org/files/v3.1/cmake-3.1.3-Linux-x86_64.sh + chmod a+x cmake-3.1.3-Linux-x86_64.sh + sudo ./cmake-3.1.3-Linux-x86_64.sh --skip-license --prefix=/usr/local + export PATH=/usr/local/bin:$PATH + cmake --version if [ "$CC" = gcc ]; then sudo apt-get install -qq --allow-unauthenticated --force-yes --fix-missing gcc-4.8 g++-4.8 || echo "ignore install failure" - sudo update-alternatives --remove-all gcc || echo "ignore remove failure" - sudo update-alternatives --remove-all g++ || echo "ignore remove failure" + sudo update-alternatives --remove-all gcc || echo "ignore remove failure" + sudo update-alternatives --remove-all g++ || echo "ignore remove failure" + + sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 + sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20 - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20 + sudo update-alternatives --config gcc + sudo update-alternatives --config g++ - sudo update-alternatives --config gcc - sudo update-alternatives --config g++ + g++ --version fi elif [ "$TRAVIS_OS_NAME" = osx ]; then xcode-select --install - brew update || echo "suppress failures in order to ignore warnings" + brew update || echo "suppress failures in order to ignore warnings" brew doctor || echo "suppress failures in order to ignore warnings" brew list cmake || brew install cmake || echo "suppress failures in order to ignore warnings" fi -- GitLab From bd97cedb5a11c0666c14efa9d5abb9769480a884 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Mar 2015 09:51:54 -0700 Subject: [PATCH 476/782] add cep sample answers #105 --- .gitignore | 8 +++++ Rx/v2/examples/cep/CMakeLists.txt | 53 +++++++++++++++++++++++++++++++ Rx/v2/examples/cep/main.cpp | 43 +++++++++++++++++++++++++ 3 files changed, 104 insertions(+) create mode 100644 Rx/v2/examples/cep/CMakeLists.txt create mode 100644 Rx/v2/examples/cep/main.cpp diff --git a/.gitignore b/.gitignore index 73574ce..0dde6a3 100644 --- a/.gitignore +++ b/.gitignore @@ -109,6 +109,14 @@ projects/* !projects/CMake/CMakeLists.txt !projects/nuget/rxcpp.autopackage +CMakeCache.txt +CMakeFiles +*.cmake +*.log +*.vcxproj* +*.sln +Makefile + ############ ## Sublime ############ diff --git a/Rx/v2/examples/cep/CMakeLists.txt b/Rx/v2/examples/cep/CMakeLists.txt new file mode 100644 index 0000000..c04bead --- /dev/null +++ b/Rx/v2/examples/cep/CMakeLists.txt @@ -0,0 +1,53 @@ +cmake_minimum_required(VERSION 2.8) + +get_filename_component(SAMPLE_PROJECT "${CMAKE_CURRENT_SOURCE_DIR}" NAME) + +project(${SAMPLE_PROJECT}) + +FIND_PACKAGE(Threads) + +MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + MESSAGE( STATUS "using clang settings" ) + add_compile_options( -Wall -Wextra -Werror ) + add_compile_options( -std=c++11 -stdlib=libc++ ) + add_compile_options( -ftemplate-depth=1024 ) # sometimes you just do what the compiler tells you +elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU") + MESSAGE( STATUS "using gnu settings" ) + add_compile_options( -Wall -Wextra -Werror ) + add_compile_options( -std=c++11 ) +elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + MESSAGE( STATUS "using msvc settings" ) + add_compile_options( /W4 /WX ) + add_compile_options( /wd4503 ) # truncated symbol + add_compile_options( /wd4702 ) # unreachable code + add_compile_options( /bigobj ) + add_definitions( /DUNICODE /D_UNICODE ) # it is a new millenium +endif() + + +# define some folders +get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) + +MESSAGE( STATUS "RXCPP_DIR: " ${RXCPP_DIR} ) + +include_directories(SYSTEM ${RXCPP_DIR}/ext/catch/include) +include_directories(${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) + +# define the sources +set(SAMPLE_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp +) +add_executable(${SAMPLE_PROJECT} ${SAMPLE_SOURCES}) +TARGET_LINK_LIBRARIES(${SAMPLE_PROJECT} ${CMAKE_THREAD_LIBS_INIT}) + +# configure unit tests via CTest +enable_testing() +set(CTEST_CONFIGURATION_TYPE "${JOB_BUILD_CONFIGURATION}") + +add_test(NAME RunTests + WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" + COMMAND ${SAMPLE_PROJECT} ${TEST_ARGS}) \ No newline at end of file diff --git a/Rx/v2/examples/cep/main.cpp b/Rx/v2/examples/cep/main.cpp new file mode 100644 index 0000000..587595f --- /dev/null +++ b/Rx/v2/examples/cep/main.cpp @@ -0,0 +1,43 @@ + +#include "rxcpp/rx.hpp" +// create alias' to simplify code +// these are owned by the user so that +// conflicts can be managed by the user. +namespace rx=rxcpp; +namespace rxsub=rxcpp::subjects; +namespace rxu=rxcpp::util; + +#include +#include + +// At this time, RxCpp will fail to compile if the contents +// of the std namespace are merged into the global namespace +// DO NOT USE: 'using namespace std;' + +int main() +{ + auto keys = rx::observable<>::create( + [](rx::subscriber dest){ + for (;;) { + int key = std::cin.get(); + dest.on_next(key); + } + }). + publish(); + + auto a = keys. + filter([](int key){return std::tolower(key) == 'a';}); + + auto g = keys. + filter([](int key){return std::tolower(key) == 'g';}); + + a.merge(g). + subscribe([](int key){ + std::cout << key << std::endl; + }); + + // run the loop in create + keys.connect(); + + return 0; +} -- GitLab From ea776beda7d2e13293cce5606cd86bddd205a804 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Tue, 24 Mar 2015 11:57:27 -0700 Subject: [PATCH 477/782] added win_text example --- Rx/v2/examples/win_text/CMakeLists.txt | 54 +++++ Rx/v2/examples/win_text/main.cpp | 244 ++++++++++++++++++++++ Rx/v2/examples/win_text/rx_windows_user.h | 117 +++++++++++ Rx/v2/examples/win_text/unwinder.h | 54 +++++ Rx/v2/examples/win_text/windows_user.h | 118 +++++++++++ 5 files changed, 587 insertions(+) create mode 100644 Rx/v2/examples/win_text/CMakeLists.txt create mode 100644 Rx/v2/examples/win_text/main.cpp create mode 100644 Rx/v2/examples/win_text/rx_windows_user.h create mode 100644 Rx/v2/examples/win_text/unwinder.h create mode 100644 Rx/v2/examples/win_text/windows_user.h diff --git a/Rx/v2/examples/win_text/CMakeLists.txt b/Rx/v2/examples/win_text/CMakeLists.txt new file mode 100644 index 0000000..8aabd25 --- /dev/null +++ b/Rx/v2/examples/win_text/CMakeLists.txt @@ -0,0 +1,54 @@ +cmake_minimum_required(VERSION 2.8) + +get_filename_component(SAMPLE_PROJECT "${CMAKE_CURRENT_SOURCE_DIR}" NAME) + +project(${SAMPLE_PROJECT}) + +FIND_PACKAGE(Threads) + +MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} ) +if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + MESSAGE( STATUS "using clang settings" ) + add_compile_options( -Wall -Wextra -Werror ) + add_compile_options( -std=c++11 -stdlib=libc++ ) + add_compile_options( -ftemplate-depth=1024 ) # sometimes you just do what the compiler tells you +elseif (CMAKE_CXX_COMPILER_ID MATCHES "GNU") + MESSAGE( STATUS "using gnu settings" ) + add_compile_options( -Wall -Wextra -Werror ) + add_compile_options( -std=c++11 ) +elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + MESSAGE( STATUS "using msvc settings" ) + add_compile_options( /W4 /WX ) + add_compile_options( /wd4503 ) # truncated symbol + add_compile_options( /wd4702 ) # unreachable code + add_compile_options( /wd4091 ) # typedef ignored on left when no variable is declared + add_compile_options( /bigobj ) + add_definitions( /DUNICODE /D_UNICODE ) # it is a new millenium +endif() + + +# define some folders +get_filename_component(RXCPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) +get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) + +MESSAGE( STATUS "RXCPP_DIR: " ${RXCPP_DIR} ) + +include_directories(SYSTEM ${RXCPP_DIR}/ext/catch/include) +include_directories(${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) + +# define the sources +set(SAMPLE_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp +) +add_executable(${SAMPLE_PROJECT} WIN32 ${SAMPLE_SOURCES}) +TARGET_LINK_LIBRARIES(${SAMPLE_PROJECT} ${CMAKE_THREAD_LIBS_INIT}) + +# configure unit tests via CTest +enable_testing() +set(CTEST_CONFIGURATION_TYPE "${JOB_BUILD_CONFIGURATION}") + +add_test(NAME RunTests + WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" + COMMAND ${SAMPLE_PROJECT} ${TEST_ARGS}) \ No newline at end of file diff --git a/Rx/v2/examples/win_text/main.cpp b/Rx/v2/examples/win_text/main.cpp new file mode 100644 index 0000000..709cc2f --- /dev/null +++ b/Rx/v2/examples/win_text/main.cpp @@ -0,0 +1,244 @@ + +// win_text.cpp : Defines the entry point for the application. +// +// + +#define STRICT +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX + +#include +#include +#include +#include +#include +#include +#include + +#pragma comment(lib, "user32.lib") +#pragma comment(lib, "gdi32.lib") +#pragma comment(lib, "Comctl32.lib") +#pragma comment(lib, "Ole32.lib") + +#include +#include +#include +#include +#include +#include + +#include "rxcpp/rx.hpp" +// create alias' to simplify code +// these are owned by the user so that +// conflicts can be managed by the user. +namespace rx=rxcpp; +namespace rxsub=rxcpp::subjects; +namespace rxu=rxcpp::util; + +// At this time, RxCpp will fail to compile if the contents +// of the std namespace are merged into the global namespace +// DO NOT USE: 'using namespace std;' + +#include "unwinder.h" + +#include "windows_user.h" +namespace wu = windows_user; + +#include "rx_windows_user.h" +namespace rxwu = rxcpp::windows_user; + +struct RootWindow : public rxwu::rx_messages, public rxwu::enable_send_call +{ + // window class + using window_class = wu::window_class; + static LPCWSTR class_name() {return L"Scratch";} + static void change_class(WNDCLASSEX&) {} + + // createstruct parameter type + using param_type = std::wstring; + + // public methods + + // static methods use a window message per call + + static LRESULT set_title(HWND w, const std::wstring& t) { + return send_call(w, [&](RootWindow& r){ + r.set_title(t); + return 0; + }); + } + static std::wstring get_title(HWND w) { + std::wstring t; + send_call(w, [&](RootWindow& r){ + t = r.get_title(); + return 0; + }); + return t; + } + + // instance methods are accessed using static send_call(hwnd, [](RootWindow& r){. . .}); + // send_call uses one window message, the lambda can call many instance methods. + + void set_title(const std::wstring& t) { + title = t; + } + const std::wstring& get_title() { + return title; + } + + // lifetime + + // called during WM_NCDESTROY + ~RootWindow() { + PostQuitMessage(0); + } + + // called during WM_NCCREATE + RootWindow(HWND w, LPCREATESTRUCT, param_type* title) + : window(w) + , title(title ? *title : L"RootWindow") + , position{40, 10} { + // listen for the following messages + OnPaint(); + OnPrintClient(); + OnKeyDown(); + OnMovesWhileLButtonDown(); + } + +private: + // implementation + + HWND window; + std::wstring title; + POINTS position; + + void PaintContent(PAINTSTRUCT& ps) { + RECT rect; + GetClientRect (window, &rect) ; + SetTextColor(ps.hdc, 0x00000000); + SetBkMode(ps.hdc,TRANSPARENT); + rect.left=position.x; + rect.top=position.y; + DrawText( ps.hdc, title.c_str(), -1, &rect, DT_SINGLELINE | DT_NOCLIP ) ; + } + + void OnKeyDown() { + messages(). + subscribe([this](auto m) { + m.handled(); // skip DefWindowProc + + MessageBox(window, L"KeyDown", L"RootWindow", MB_OK); + // NOTE: MessageBox pumps messages, but this subscription only + // receives messages if it is suspended by 'for await', so any + // WM_KEYDOWN arriving while the message box is up is not delivered. + // the other subscriptions will receive messages. + }); + } + + void OnMovesWhileLButtonDown() { + + auto moves_while_lbutton_down = messages(). + map( + [this](auto m) { + m.handled(); // skip DefWindowProc + + return this->messages(). + take_until(this->messages()); + }). + merge(); + + moves_while_lbutton_down. + subscribe([this](auto m) { + m.handled(); // skip DefWindowProc + + position = MAKEPOINTS(m.lParam); + InvalidateRect(window, nullptr, true); + }); + } + + void OnPaint() { + messages(). + subscribe([this](auto m) { + m.handled(); // skip DefWindowProc + + PAINTSTRUCT ps; + BeginPaint(window, &ps); + PaintContent(ps); + EndPaint(window, &ps); + }); + } + + void OnPrintClient() { + messages(). + subscribe([this](auto m) { + m.handled(); // skip DefWindowProc + + PAINTSTRUCT ps; + ps.hdc = m.wParam; + GetClientRect(window, &ps.rcPaint); + PaintContent(ps); + }); + } +}; + +int PASCAL +wWinMain(HINSTANCE hinst, HINSTANCE, LPWSTR, int nShowCmd) +{ + HRESULT hr = S_OK; + + hr = CoInitialize(NULL); + if (FAILED(hr)) + { + return FALSE; + } + ON_UNWIND_AUTO([&]{CoUninitialize();}); + + InitCommonControls(); + + RootWindow::window_class::Register(); + + LONG winerror = ERROR_SUCCESS; + + std::wstring title{L"Scratch App - RootWindow"}; + + // normal create window call, just takes the class name and optional create parameters + HWND window = CreateWindow( + RootWindow::window_class::Name(), title.c_str(), + WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, + NULL, NULL, + hinst, + &title); + if (!window) {winerror = GetLastError();} + + if (!!winerror || !window) + { + return winerror; + } + + ShowWindow(window, nShowCmd); + + // interact with window safely on the UI thread from another thread + auto settitle = std::async([window](){ + + // by static method (two SendMessage) + RootWindow::set_title(window, L"SET_TITLE! " + RootWindow::get_title(window)); + + // or multiple instance methods (one SendMessage) + RootWindow::send_call(window, [](RootWindow& r){ + r.set_title(L"SEND_CALL! " + r.get_title()); + return 0; + }); + }); + + MSG msg = {}; + while (GetMessage(&msg, NULL, 0, 0)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + + settitle.get(); + + return 0; +} diff --git a/Rx/v2/examples/win_text/rx_windows_user.h b/Rx/v2/examples/win_text/rx_windows_user.h new file mode 100644 index 0000000..d8054fc --- /dev/null +++ b/Rx/v2/examples/win_text/rx_windows_user.h @@ -0,0 +1,117 @@ +#pragma once + +namespace rxcpp { namespace windows_user { + + struct rx_messages + { + struct Result + { + LRESULT lres = 0; + bool handled = false; + }; + + struct Message + { + template + static auto is() { return [](Message m){ return m.message == WM; }; } + + HWND hWnd; + UINT message; + WPARAM wParam; + LPARAM lParam; + Result* result; + + void handled() { result->handled = true; } + void lresult(LRESULT lres) {result->lres = lres; } + + template + T wparam_cast(){ + return *reinterpret_cast(std::addressof(wParam)); + } + + template + T lparam_cast(){ + return *reinterpret_cast(std::addressof(lParam)); + } + }; + + template + struct TypedMessage + { + static auto as() { return [](Message m){return TypedMessage{m}; }; } + + TypedMessage(Message m) + : hWnd(m.hWnd) + , message(m.message) + , wParam(m.wparam_cast()) + , lParam(m.lparam_cast()) + , result(m.result) + {} + + HWND hWnd; + UINT message; + WPARAM_t wParam; + LPARAM_t lParam; + Result* result; + + void handled() { result->handled = true; } + void lresult(LRESULT lres) {result->lres = lres; } + }; + + subjects::subject subject; + subscriber sub; + + ~rx_messages() { + sub.on_completed(); + } + rx_messages() : sub(subject.get_subscriber()) {} + + std::tuple message(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { + Result result; + auto m = Message{hWnd, message, wParam, lParam, &result}; + try { + sub.on_next(m); + } catch(...) { + sub.on_error(std::current_exception()); + } + return std::make_tuple(result.handled, result.lres); + } + + observable messages() { + return subject.get_observable(); + } + + template + observable messages() { + return messages().filter(Message::is()); + } + + template + observable> messages() { + return messages().map(TypedMessage::as()); + } + + }; + + template + struct enable_send_call + { + static LRESULT send_call(HWND w, std::function f) { + auto fp = reinterpret_cast(std::addressof(f)); + return SendMessage(w, WM_USER+1, 0, fp); + } + + void OnSendCall() { + auto derived = static_cast(this); + derived->messages*>(). + subscribe([=](auto m) { + m.handled(); // skip DefWindowProc + m.lresult((*m.lParam)(*derived)); + }); + } + + enable_send_call() { + OnSendCall(); + } + }; +} } diff --git a/Rx/v2/examples/win_text/unwinder.h b/Rx/v2/examples/win_text/unwinder.h new file mode 100644 index 0000000..a01a170 --- /dev/null +++ b/Rx/v2/examples/win_text/unwinder.h @@ -0,0 +1,54 @@ +#pragma once + +namespace unwinder { namespace detail { + + template + class unwinder + { + public: + ~unwinder() noexcept + { + if (!!function) + { + (*function)(); + } + } + + explicit unwinder(Function* functionArg) + : function(functionArg) + { + } + + void dismiss() + { + function = nullptr; + } + + unwinder& operator=(nullptr_t) { + dismiss(); + return *this; + } + + private: + unwinder(); + unwinder(const unwinder&); + unwinder& operator=(const unwinder&); + + Function* function; + }; +} } + +#define UNWIND_MAKE_IDENTIFIER_EXPLICIT_PASTER(Prefix, Suffix) Prefix ## Suffix +#define UNWIND_MAKE_IDENTIFIER_EXPLICIT(Prefix, Suffix) UNWIND_MAKE_IDENTIFIER_EXPLICIT_PASTER(Prefix, Suffix) + +#define UNWIND_MAKE_IDENTIFIER(Prefix) UNWIND_MAKE_IDENTIFIER_EXPLICIT(Prefix, __LINE__) + +#define ON_UNWIND(Name, Function) \ + ON_UNWIND_EXPLICIT(uwfunc_ ## Name, Name, Function) + +#define ON_UNWIND_AUTO(Function) \ + ON_UNWIND_EXPLICIT(UNWIND_MAKE_IDENTIFIER(uwfunc_), UNWIND_MAKE_IDENTIFIER(unwind_), Function) + +#define ON_UNWIND_EXPLICIT(FunctionName, UnwinderName, Function) \ + auto FunctionName = (Function); \ + ::unwinder::detail::unwinder UnwinderName(std::addressof(FunctionName)) diff --git a/Rx/v2/examples/win_text/windows_user.h b/Rx/v2/examples/win_text/windows_user.h new file mode 100644 index 0000000..418f73f --- /dev/null +++ b/Rx/v2/examples/win_text/windows_user.h @@ -0,0 +1,118 @@ +#pragma once + +namespace windows_user { + + EXTERN_C IMAGE_DOS_HEADER __ImageBase; + inline HINSTANCE GetCurrentInstance(){ return ((HINSTANCE)&__ImageBase); } + + template + LRESULT CALLBACK WindowCallback(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) noexcept; + + template + class window_class + { + public: + static LPCWSTR Name() { + return Type::class_name(); + } + + static ATOM Register() { + WNDCLASSEX wcex = {}; + wcex.cbSize = sizeof(WNDCLASSEX); + + // defaults that can be overriden + wcex.style = CS_HREDRAW | CS_VREDRAW; + wcex.hInstance = GetCurrentInstance(); + wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); + wcex.style = 0; + wcex.hIcon = NULL; + wcex.hCursor = LoadCursor(NULL, IDC_ARROW); + wcex.lpszMenuName = NULL; + + Type::change_class(wcex); + + // not overridable + wcex.lpszClassName = Name(); + wcex.lpfnWndProc = WindowCallback; + + return RegisterClassEx(&wcex); + } + + private: + ~window_class(); + window_class(); + window_class(window_class&); + window_class& operator=(window_class&); + }; + + namespace detail { + template + std::unique_ptr find(HWND hwnd) { + return std::unique_ptr(reinterpret_cast(GetWindowLongPtr(hwnd, GWLP_USERDATA))); + } + + void erase(HWND hwnd) { + SetWindowLongPtr(hwnd, GWLP_USERDATA, 0); + } + + template + std::unique_ptr insert(HWND hwnd, std::unique_ptr type) { + if (!type) { + return nullptr; + } + + SetLastError(0); + + ON_UNWIND(unwind_userdata, [&](){erase(hwnd);}); + auto result = SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast(type.get())); + + LONG winerror = !result ? GetLastError() : ERROR_SUCCESS; + + if (!!winerror || !!result) { + return nullptr; + } + + unwind_userdata.dismiss(); + return type; + } + } + + template + LRESULT CALLBACK WindowCallback(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) noexcept { + auto type = detail::find(hWnd); + // don't delete type + ON_UNWIND(unwind_type, [&](){type.release();}); + + if (message == WM_NCCREATE) { + if (type) { + // the slot where we would store our type instance is full. abort. + return FALSE; + } + auto cs = reinterpret_cast(lParam); + auto param = reinterpret_cast(cs->lpCreateParams); + type = detail::insert(hWnd, std::unique_ptr(new (std::nothrow) Type(hWnd, cs, param))); + if (!type) { + return FALSE; + } + } + + LRESULT lResult = 0; + bool handled = false; + + if (type) { + std::tie(handled, lResult) = type->message(hWnd, message, wParam, lParam); + } + + if (!handled) { + lResult = DefWindowProc(hWnd, message, wParam, lParam); + } + + if (message == WM_NCDESTROY) { + detail::erase(hWnd); + // let type destruct + unwind_type.dismiss(); + } + + return lResult; + } +} -- GitLab From b38a4f085b9abd9dba694964e5bc68e1a92f3fb8 Mon Sep 17 00:00:00 2001 From: ben Date: Tue, 17 Feb 2015 16:26:54 +0800 Subject: [PATCH 478/782] Prefer std::make_shared to using std::shared_ptr(new T()) --- Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-concat.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-concat_map.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-flat_map.hpp | 4 ++-- Rx/v2/src/rxcpp/operators/rx-merge.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-repeat.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-retry.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-skip.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-skip_until.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-take.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-take_until.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-zip.hpp | 2 +- Rx/v2/src/rxcpp/rx-scheduler.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 2 +- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 14 ++++++-------- 20 files changed, 26 insertions(+), 28 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index d051f83..8441dc4 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -163,7 +163,7 @@ struct combine_latest : public operator_base(new combine_latest_state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); subscribe_all(state, typename rxu::values_from::type()); } diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index 01f023d..a92b8b3 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -131,7 +131,7 @@ struct concat auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription - auto state = std::shared_ptr(new concat_state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); state->sourceLifetime = composite_subscription(); diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index 4d9fb5c..49f50af 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -180,7 +180,7 @@ struct concat_map auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription - auto state = std::shared_ptr(new concat_map_state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); state->sourceLifetime = composite_subscription(); diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index 7cce410..dcc3521 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -112,7 +112,7 @@ struct flat_map auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); composite_subscription outercs; @@ -238,4 +238,4 @@ auto flat_map(CollectionSelector&& s, ResultSelector&& rs, Coordination&& sf) } -#endif +#endif \ No newline at end of file diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 6e5dd2f..17409d3 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -77,7 +77,7 @@ struct merge auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription - auto state = std::shared_ptr(new merge_state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); composite_subscription outercs; diff --git a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp index b9038ac..332d2da 100644 --- a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp @@ -84,7 +84,7 @@ struct repeat : public operator_base }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, s)); + auto state = std::make_shared(initial, s); // start the first iteration state->do_subscribe(); diff --git a/Rx/v2/src/rxcpp/operators/rx-retry.hpp b/Rx/v2/src/rxcpp/operators/rx-retry.hpp index acfa20b..baf2111 100644 --- a/Rx/v2/src/rxcpp/operators/rx-retry.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-retry.hpp @@ -81,7 +81,7 @@ namespace rxcpp { }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, s)); + auto state = std::make_shared(initial, s); // start the first iteration state->do_subscribe(); diff --git a/Rx/v2/src/rxcpp/operators/rx-skip.hpp b/Rx/v2/src/rxcpp/operators/rx-skip.hpp index 94ebe5a..9e4611a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip.hpp @@ -63,7 +63,7 @@ struct skip : public operator_base output_type out; }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, s)); + auto state = std::make_shared(initial, s); composite_subscription source_lifetime; diff --git a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp index 4b4644f..c717fad 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp @@ -77,7 +77,7 @@ struct skip_until : public operator_base auto coordinator = initial.coordination.create_coordinator(); // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, std::move(coordinator), std::move(s))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(s)); auto trigger = on_exception( [&](){return state->coordinator.in(state->trigger);}, diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp index 4142890..e38cd8d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp @@ -70,7 +70,7 @@ struct subscribe_on : public operator_base auto controller = coordinator.get_worker(); // take a copy of the values for each subscription - auto state = std::shared_ptr(new subscribe_on_state_type(initial, std::move(coordinator), std::move(s))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(s)); auto disposer = [=](const rxsc::schedulable&){ state->source_lifetime.unsubscribe(); diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp index 91a20a7..35b8e67 100644 --- a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -80,7 +80,7 @@ struct switch_on_next auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription - auto state = std::shared_ptr(new switch_state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); composite_subscription outercs; diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index 182a20f..c7259a3 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -63,7 +63,7 @@ struct take : public operator_base output_type out; }; // take a copy of the values for each subscription - auto state = std::shared_ptr(new state_type(initial, s)); + auto state = std::make_shared(initial, s); composite_subscription source_lifetime; diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index e4109cd..422679a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -77,7 +77,7 @@ struct take_until : public operator_base auto coordinator = initial.coordination.create_coordinator(s.get_subscription()); // take a copy of the values for each subscription - auto state = std::shared_ptr(new take_until_state_type(initial, std::move(coordinator), std::move(s))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(s)); auto trigger = on_exception( [&](){return state->coordinator.in(state->trigger);}, diff --git a/Rx/v2/src/rxcpp/operators/rx-zip.hpp b/Rx/v2/src/rxcpp/operators/rx-zip.hpp index d62073d..36f4915 100644 --- a/Rx/v2/src/rxcpp/operators/rx-zip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-zip.hpp @@ -155,7 +155,7 @@ struct zip : public operator_base(new zip_state_type(initial, std::move(coordinator), std::move(scbr))); + auto state = std::make_shared(initial, std::move(coordinator), std::move(scbr)); subscribe_all(state, typename rxu::values_from::type()); } diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index bd490fa..9e3d1a6 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -780,7 +780,7 @@ auto worker::schedule_periodically(clock_type::time_point initial, clock_type::d } template void worker::schedule_periodically_rebind(clock_type::time_point initial, clock_type::duration period, const schedulable& scbl, ArgN&&... an) const { - std::shared_ptr target(new clock_type::time_point(initial)); + auto target = std::make_shared(initial); auto activity = make_schedulable(scbl, *this, std::forward(an)...); auto periodic = make_schedulable( activity, diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 64ae60b..677291f 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -228,7 +228,7 @@ private: public: current_thread() - : wi(new current_worker()) + : wi(std::make_shared()) { } virtual ~current_thread() diff --git a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp index b5adf5b..2771955 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp @@ -91,7 +91,7 @@ public: } virtual worker create_worker(composite_subscription cs) const { - return worker(cs, std::shared_ptr(new loop_worker(cs, loops[++count % loops.size()]))); + return worker(cs, std::make_shared(cs, loops[++count % loops.size()])); } const static scheduler instance; }; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp index c990837..d610d33 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -56,7 +56,7 @@ private: public: immediate() - : wi(new immediate_worker()) + : wi(std::make_shared()) { } virtual ~immediate() diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp index 4d60cb6..9795b59 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -160,7 +160,7 @@ public: } virtual worker create_worker(composite_subscription cs) const { - return worker(cs, std::shared_ptr(new new_worker(cs, factory))); + return worker(cs, std::make_shared(cs, factory)); } const static scheduler instance; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 0d65d5f..2cacca2 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -124,7 +124,7 @@ public: public: test_type() - : state(new test_type_state()) + : state(std::make_shared()) { } @@ -133,8 +133,7 @@ public: } virtual worker create_worker(composite_subscription cs) const { - std::shared_ptr wi(new test_type_worker(state)); - return worker(cs, wi); + return worker(cs, std::make_shared(state)); } bool is_enabled() const {return state->is_enabled();} @@ -143,8 +142,7 @@ public: } std::shared_ptr create_test_type_worker_interface() const { - std::shared_ptr wi(new test_type_worker(state)); - return wi; + return std::make_shared(state); } template @@ -188,7 +186,7 @@ subscriber> test_type::test_type_worker::make_subsc typedef typename rxn::notification notification_type; typedef rxn::recorded recorded_type; - std::shared_ptr> ts(new mock_observer(state)); + auto ts = std::make_shared>(state); return rxcpp::make_subscriber(rxt::testable_observer(ts, make_observer_dynamic( // on_next @@ -272,7 +270,7 @@ public: template rxt::testable_observable test_type::make_cold_observable(std::vector>>> messages) const { - auto co = std::shared_ptr>(new cold_observable(state, create_worker(composite_subscription()), std::move(messages))); + auto co = std::make_shared>(state, create_worker(composite_subscription()), std::move(messages)); return rxt::testable_observable(co); } @@ -469,7 +467,7 @@ public: { } }; - std::shared_ptr state(new state_type(this->make_subscriber())); + auto state = std::make_shared(this->make_subscriber()); schedule_absolute(created, [createSource, state](const schedulable&) { state->source.reset(new typename state_type::source_type(createSource())); -- GitLab From d7a795119a52d76fba64a8bf2fa672575e07a012 Mon Sep 17 00:00:00 2001 From: ben Date: Tue, 17 Feb 2015 17:05:29 +0800 Subject: [PATCH 479/782] Don't return std::move(t); It prevents NRVO and is almost always wrong --- Ix/CPP/src/cpplinq/linq.hpp | 2 +- Ix/CPP/src/cpplinq/linq_last.hpp | 4 ++-- Ix/CPP/src/cpplinq/linq_skip.hpp | 2 +- Ix/CPP/src/cpplinq/linq_take.hpp | 2 +- Rx/v2/src/rxcpp/operators/rx-observe_on.hpp | 4 ++-- Rx/v2/src/rxcpp/rx-coordination.hpp | 8 ++++---- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 4 ++-- Rx/v2/test/operators/group_by.cpp | 2 +- 8 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Ix/CPP/src/cpplinq/linq.hpp b/Ix/CPP/src/cpplinq/linq.hpp index 5f08588..80894e8 100644 --- a/Ix/CPP/src/cpplinq/linq.hpp +++ b/Ix/CPP/src/cpplinq/linq.hpp @@ -526,7 +526,7 @@ template linq_driver::iterator>> from(TContainer& c) { auto cur = iter_cursor::iterator>(begin(c), end(c)); - return std::move(cur); + return cur; } template const linq_driver& from(const linq_driver& c) diff --git a/Ix/CPP/src/cpplinq/linq_last.hpp b/Ix/CPP/src/cpplinq/linq_last.hpp index fd08823..cb2bf76 100644 --- a/Ix/CPP/src/cpplinq/linq_last.hpp +++ b/Ix/CPP/src/cpplinq/linq_last.hpp @@ -17,7 +17,7 @@ namespace cpplinq { if (c.empty()) break; elem = c.get(); } - return std::move(elem); + return elem; } // TODO: bidirectional iterator in constant time @@ -54,7 +54,7 @@ namespace cpplinq { elem = c.get(); c.inc(); } - return std::move(elem); + return elem; } template diff --git a/Ix/CPP/src/cpplinq/linq_skip.hpp b/Ix/CPP/src/cpplinq/linq_skip.hpp index 422592a..bcaf5f4 100644 --- a/Ix/CPP/src/cpplinq/linq_skip.hpp +++ b/Ix/CPP/src/cpplinq/linq_skip.hpp @@ -22,7 +22,7 @@ namespace cpplinq cur.inc(); } cur.forget(); - return std::move(cur); + return cur; } private: diff --git a/Ix/CPP/src/cpplinq/linq_take.hpp b/Ix/CPP/src/cpplinq/linq_take.hpp index 63f7449..7e16d6e 100644 --- a/Ix/CPP/src/cpplinq/linq_take.hpp +++ b/Ix/CPP/src/cpplinq/linq_take.hpp @@ -56,7 +56,7 @@ namespace cpplinq if (cur.size() > n) { cur.truncate(n); } - return std::move(cur); + return cur; } } diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 82235f4..dfad938 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -237,12 +237,12 @@ class observe_on_one_worker : public coordination_base template auto out(Subscriber s) const -> Subscriber { - return std::move(s); + return s; } template auto act(F f) const -> F { - return std::move(f); + return f; } }; diff --git a/Rx/v2/src/rxcpp/rx-coordination.hpp b/Rx/v2/src/rxcpp/rx-coordination.hpp index 0b95db3..560304c 100644 --- a/Rx/v2/src/rxcpp/rx-coordination.hpp +++ b/Rx/v2/src/rxcpp/rx-coordination.hpp @@ -125,17 +125,17 @@ class identity_one_worker : public coordination_base template auto in(Observable o) const -> Observable { - return std::move(o); + return o; } template auto out(Subscriber s) const -> Subscriber { - return std::move(s); + return s; } template auto act(F f) const -> F { - return std::move(f); + return f; } }; @@ -250,7 +250,7 @@ class serialize_one_worker : public coordination_base template auto in(Observable o) const -> Observable { - return std::move(o); + return o; } template auto out(const Subscriber& s) const diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 4e167bc..9625a14 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -222,12 +222,12 @@ class synchronize_in_one_worker : public coordination_base template auto out(Subscriber s) const -> Subscriber { - return std::move(s); + return s; } template auto act(F f) const -> F { - return std::move(f); + return f; } }; diff --git a/Rx/v2/test/operators/group_by.cpp b/Rx/v2/test/operators/group_by.cpp index 8c80fe3..6677f9e 100644 --- a/Rx/v2/test/operators/group_by.cpp +++ b/Rx/v2/test/operators/group_by.cpp @@ -168,7 +168,7 @@ std::string trim(std::string s) { s.erase(s.end() - (last-s.rbegin()), s.end()); } s.erase(s.begin(), first); - return std::move(s); + return s; } bool tolowerLess(char lhs, char rhs) { -- GitLab From 71254f2e6a51fe861869f22a1eaebd9d09001132 Mon Sep 17 00:00:00 2001 From: ben Date: Tue, 17 Feb 2015 19:27:02 +0800 Subject: [PATCH 480/782] Change the way statics work to avoid namespace detail { --- Rx/v2/src/rxcpp/rx-notification.hpp | 53 +++++----------- Rx/v2/src/rxcpp/rx-scheduler.hpp | 12 ++-- Rx/v2/src/rxcpp/rx-subscription.hpp | 17 ++++-- Rx/v2/src/rxcpp/rx-util.hpp | 8 --- .../src/rxcpp/schedulers/rx-currentthread.hpp | 7 +-- Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp | 7 +-- Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp | 7 +-- Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp | 8 +-- Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 61 +++++-------------- 9 files changed, 56 insertions(+), 124 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-notification.hpp b/Rx/v2/src/rxcpp/rx-notification.hpp index f8cafbb..3928fd5 100644 --- a/Rx/v2/src/rxcpp/rx-notification.hpp +++ b/Rx/v2/src/rxcpp/rx-notification.hpp @@ -205,47 +205,24 @@ private: return std::make_shared(ep); } - struct on_next_factory - { - type operator()(T value) const { - return std::make_shared(std::move(value)); - } - }; - - struct on_completed_factory - { - type operator()() const { - return std::make_shared(); - } - }; - - struct on_error_factory - { - template - type operator()(Exception&& e) const { - return make_on_error(typename std::conditional< - std::is_same, std::exception_ptr>::value, - exception_ptr_tag, exception_tag>::type(), - std::forward(e)); - } - }; public: - const static on_next_factory on_next; - const static on_completed_factory on_completed; - const static on_error_factory on_error; -}; - -template -//static -RXCPP_SELECT_ANY const typename notification::on_next_factory notification::on_next = notification::on_next_factory(); + template + static type on_next(U value) { + return std::make_shared(std::move(value)); + } -template -//static -RXCPP_SELECT_ANY const typename notification::on_completed_factory notification::on_completed = notification::on_completed_factory(); + static type on_completed() { + return std::make_shared(); + } -template -//static -RXCPP_SELECT_ANY const typename notification::on_error_factory notification::on_error = notification::on_error_factory(); + template + static type on_error(Exception&& e) { + return make_on_error(typename std::conditional< + std::is_same, std::exception_ptr>::value, + exception_ptr_tag, exception_tag>::type(), + std::forward(e)); + } +}; template bool operator == (const std::shared_ptr>& lhs, const std::shared_ptr>& rhs) { diff --git a/Rx/v2/src/rxcpp/rx-scheduler.hpp b/Rx/v2/src/rxcpp/rx-scheduler.hpp index 9e3d1a6..d9d4741 100644 --- a/Rx/v2/src/rxcpp/rx-scheduler.hpp +++ b/Rx/v2/src/rxcpp/rx-scheduler.hpp @@ -25,6 +25,11 @@ typedef std::shared_ptr const_worker_interface_ptr; typedef std::shared_ptr scheduler_interface_ptr; typedef std::shared_ptr const_scheduler_interface_ptr; +inline action_ptr shared_empty() { + static action_ptr shared_empty = std::make_shared(); + return shared_empty; +} + } // It is essential to keep virtual function calls out of an inner loop. @@ -123,7 +128,6 @@ class action : public action_base { typedef action this_type; detail::action_ptr inner; - static detail::action_ptr shared_empty; public: action() { @@ -135,7 +139,7 @@ public: /// return the empty action inline static action empty() { - return action(shared_empty); + return action(detail::shared_empty()); } /// call the function @@ -640,10 +644,6 @@ inline void action::operator()(const schedulable& s, const recurse& r) const { (*inner)(s, r); } -//static -RXCPP_SELECT_ANY detail::action_ptr action::shared_empty = detail::action_ptr(new detail::action_type()); - - inline action make_action_empty() { return action::empty(); } diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index a5fce21..77c9b20 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -210,6 +210,8 @@ auto make_subscription(Unsubscribe&& u) return subscription(static_subscription(std::forward(u))); } +class composite_subscription; + namespace detail { struct tag_composite_subscription_empty {}; @@ -348,6 +350,8 @@ public: } }; +inline composite_subscription shared_empty(); + } class composite_subscription @@ -358,8 +362,6 @@ class composite_subscription public: typedef subscription::weak_state_type weak_subscription; - static composite_subscription shared_empty; - composite_subscription(detail::tag_composite_subscription_empty et) : inner_type(et) , subscription() // use empty base @@ -393,7 +395,7 @@ public: } static inline composite_subscription empty() { - return shared_empty; + return detail::shared_empty(); } using subscription::is_subscribed; @@ -438,9 +440,14 @@ inline bool operator!=(const composite_subscription& lhs, const composite_subscr return !(lhs == rhs); } -//static -RXCPP_SELECT_ANY composite_subscription composite_subscription::shared_empty = composite_subscription(detail::tag_composite_subscription_empty()); +namespace detail { +inline composite_subscription shared_empty() { + static composite_subscription shared_empty = composite_subscription(tag_composite_subscription_empty()); + return shared_empty; +} + +} template class resource : public subscription_base diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index b2493f3..faedf0f 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -15,14 +15,6 @@ #endif #endif -#if !defined(RXCPP_SELECT_ANY) -#if defined(_MSC_VER) -#define RXCPP_SELECT_ANY __declspec(selectany) -#else -#define RXCPP_SELECT_ANY __attribute__((weak)) -#endif -#endif - #if !defined(RXCPP_DELETE) #if defined(_MSC_VER) #define RXCPP_DELETE __pragma(warning(disable: 4822)) =delete diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 677291f..4f9f9b5 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -248,14 +248,11 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(std::move(cs), wi); } - const static scheduler instance; }; -//static -RXCPP_SELECT_ANY const scheduler current_thread::instance = make_scheduler(); - inline const scheduler& make_current_thread() { - return current_thread::instance; + static scheduler instance = make_scheduler(); + return instance; } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp index 2771955..18bfee5 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-eventloop.hpp @@ -93,14 +93,11 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(cs, std::make_shared(cs, loops[++count % loops.size()])); } - const static scheduler instance; }; -//static -RXCPP_SELECT_ANY const scheduler event_loop::instance = make_scheduler(); - inline scheduler make_event_loop() { - return event_loop::instance; + static scheduler instance = make_scheduler(); + return instance; } inline scheduler make_event_loop(thread_factory tf) { return make_scheduler(tf); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp index d610d33..0d2b695 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-immediate.hpp @@ -70,14 +70,11 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(std::move(cs), wi); } - const static scheduler instance; }; -//static -RXCPP_SELECT_ANY const scheduler immediate::instance = make_scheduler(); - inline const scheduler& make_immediate() { - return immediate::instance; + static scheduler instance = make_scheduler(); + return instance; } } diff --git a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp index 9795b59..2e24c0f 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-newthread.hpp @@ -162,15 +162,11 @@ public: virtual worker create_worker(composite_subscription cs) const { return worker(cs, std::make_shared(cs, factory)); } - - const static scheduler instance; }; -//static -RXCPP_SELECT_ANY const scheduler new_thread::instance = make_scheduler(); - inline scheduler make_new_thread() { - return new_thread::instance; + static scheduler instance = make_scheduler(); + return instance; } inline scheduler make_new_thread(thread_factory tf) { return make_scheduler(tf); diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 2cacca2..20ad0bf 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -376,37 +376,23 @@ public: messages() {} - struct on_next_factory - { - recorded_type operator()(long ticks, T value) const { - return recorded_type(ticks, notification_type::on_next(value)); - } - }; - struct on_completed_factory - { - recorded_type operator()(long ticks) const { - return recorded_type(ticks, notification_type::on_completed()); - } - }; - struct on_error_factory - { - template - recorded_type operator()(long ticks, Exception&& e) const { - return recorded_type(ticks, notification_type::on_error(std::forward(e))); - } - }; + template + static recorded_type next(long ticks, U value) { + return recorded_type(ticks, notification_type::on_next(std::move(value))); + } - static const on_next_factory next; - static const on_completed_factory completed; - static const on_error_factory error; + static recorded_type completed(long ticks) { + return recorded_type(ticks, notification_type::on_completed()); + } - struct subscribe_factory - { - rxn::subscription operator()(long subscribeAt, long unsubscribeAt) const { - return rxn::subscription(subscribeAt, unsubscribeAt); - } - }; - static const subscribe_factory subscribe; + template + static recorded_type error(long ticks, Exception&& e) { + return recorded_type(ticks, notification_type::on_error(std::forward(e))); + } + + static rxn::subscription subscribe(long subscribe, long unsubscribe) { + return rxn::subscription(subscribe, unsubscribe); + } }; class test_worker : public worker @@ -583,23 +569,6 @@ public: } }; -template -//static -RXCPP_SELECT_ANY const typename test::messages::on_next_factory test::messages::next = test::messages::on_next_factory(); - -template -//static -RXCPP_SELECT_ANY const typename test::messages::on_completed_factory test::messages::completed = test::messages::on_completed_factory(); - -template -//static -RXCPP_SELECT_ANY const typename test::messages::on_error_factory test::messages::error = test::messages::on_error_factory(); - -template -//static -RXCPP_SELECT_ANY const typename test::messages::subscribe_factory test::messages::subscribe = test::messages::subscribe_factory(); - - inline test make_test() { return test(std::make_shared()); -- GitLab From bd3eecdd5c8cbdb6b4a801821a70cd78af45dcd5 Mon Sep 17 00:00:00 2001 From: Kirk Shoop Date: Wed, 25 Feb 2015 12:28:34 -0800 Subject: [PATCH 481/782] schedule observer and subscription in buffer and window when using time --- Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp | 118 ++++++++-- .../rxcpp/operators/rx-buffer_time_count.hpp | 118 ++++++++-- Rx/v2/src/rxcpp/operators/rx-window_time.hpp | 115 +++++++-- .../rxcpp/operators/rx-window_time_count.hpp | 126 +++++++--- Rx/v2/test/operators/buffer.cpp | 106 ++++----- Rx/v2/test/operators/window.cpp | 220 +++++++++--------- 6 files changed, 543 insertions(+), 260 deletions(-) diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp index 5948347..f1edbe6 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -53,14 +53,16 @@ struct buffer_with_time struct buffer_with_time_subscriber_values : public buffer_with_time_values { - buffer_with_time_subscriber_values(dest_type d, buffer_with_time_values v, coordinator_type c) + buffer_with_time_subscriber_values(composite_subscription cs, dest_type d, buffer_with_time_values v, coordinator_type c) : buffer_with_time_values(v) + , cs(std::move(cs)) , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) , expected(worker.now()) { } + composite_subscription cs; dest_type dest; coordinator_type coordinator; rxsc::worker worker; @@ -69,55 +71,125 @@ struct buffer_with_time }; std::shared_ptr state; - buffer_with_time_observer(dest_type d, buffer_with_time_values v, coordinator_type c) - : state(std::make_shared(buffer_with_time_subscriber_values(std::move(d), v, std::move(c)))) + buffer_with_time_observer(composite_subscription cs, dest_type d, buffer_with_time_values v, coordinator_type c) + : state(std::make_shared(buffer_with_time_subscriber_values(std::move(cs), std::move(d), v, std::move(c)))) { auto localState = state; + + auto disposer = [=](const rxsc::schedulable&){ + localState->cs.unsubscribe(); + localState->dest.unsubscribe(); + localState->worker.unsubscribe(); + }; + auto selectedDisposer = on_exception( + [&](){return localState->coordinator.act(disposer);}, + localState->dest); + if (selectedDisposer.empty()) { + return; + } + + localState->dest.add([=](){ + localState->worker.schedule(selectedDisposer.get()); + }); + localState->cs.add([=](){ + localState->worker.schedule(selectedDisposer.get()); + }); + + // + // The scheduler is FIFO for any time T. Since the observer is scheduling + // on_next/on_error/oncompleted the timed schedule calls must be resheduled + // when they occur to ensure that production happens after on_next/on_error/oncompleted + // + auto produce_buffer = [localState](const rxsc::schedulable&) { localState->dest.on_next(std::move(localState->chunks.front())); localState->chunks.pop_front(); }; - auto create_buffer = [localState, produce_buffer](const rxsc::schedulable&) { + auto selectedProduce = on_exception( + [&](){return localState->coordinator.act(produce_buffer);}, + localState->dest); + if (selectedProduce.empty()) { + return; + } + + auto create_buffer = [localState, selectedProduce](const rxsc::schedulable&) { localState->chunks.emplace_back(); auto produce_at = localState->expected + localState->period; localState->expected += localState->skip; - localState->worker.schedule(produce_at, produce_buffer); + localState->worker.schedule(produce_at, [localState, selectedProduce](const rxsc::schedulable&) { + localState->worker.schedule(selectedProduce.get()); + }); }; + auto selectedCreate = on_exception( + [&](){return localState->coordinator.act(create_buffer);}, + localState->dest); + if (selectedCreate.empty()) { + return; + } state->worker.schedule_periodically( state->expected, state->skip, - create_buffer); + [localState, selectedCreate](const rxsc::schedulable&) { + localState->worker.schedule(selectedCreate.get()); + }); } void on_next(T v) const { - for(auto& chunk : state->chunks) { - chunk.push_back(v); + auto localState = state; + auto work = [v, localState](const rxsc::schedulable&){ + for(auto& chunk : localState->chunks) { + chunk.push_back(v); + } + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; } + localState->worker.schedule(selectedWork.get()); } void on_error(std::exception_ptr e) const { - state->dest.on_error(e); + auto localState = state; + auto work = [e, localState](const rxsc::schedulable&){ + localState->dest.on_error(e); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; + } + localState->worker.schedule(selectedWork.get()); } void on_completed() const { - auto done = on_exception( - [&](){ - while (!state->chunks.empty()) { - state->dest.on_next(std::move(state->chunks.front())); - state->chunks.pop_front(); - } - return true; - }, - state->dest); - if (done.empty()) { + auto localState = state; + auto work = [localState](const rxsc::schedulable&){ + on_exception( + [&](){ + while (!localState->chunks.empty()) { + localState->dest.on_next(std::move(localState->chunks.front())); + localState->chunks.pop_front(); + } + return true; + }, + localState->dest); + localState->dest.on_completed(); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { return; } - state->dest.on_completed(); + localState->worker.schedule(selectedWork.get()); } static subscriber> make(dest_type d, buffer_with_time_values v) { - auto cs = d.get_subscription(); - auto coordinator = v.coordination.create_coordinator(cs); + auto cs = composite_subscription(); + auto coordinator = v.coordination.create_coordinator(); - return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v), std::move(coordinator))); + return make_subscriber(cs, this_type(cs, std::move(d), std::move(v), std::move(coordinator))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp index 87b6c2a..ba8d62a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp @@ -53,14 +53,16 @@ struct buffer_with_time_or_count struct buffer_with_time_or_count_subscriber_values : public buffer_with_time_or_count_values { - buffer_with_time_or_count_subscriber_values(dest_type d, buffer_with_time_or_count_values v, coordinator_type c) + buffer_with_time_or_count_subscriber_values(composite_subscription cs, dest_type d, buffer_with_time_or_count_values v, coordinator_type c) : buffer_with_time_or_count_values(std::move(v)) + , cs(std::move(cs)) , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) , chunk_id(0) { } + composite_subscription cs; dest_type dest; coordinator_type coordinator; rxsc::worker worker; @@ -70,50 +72,116 @@ struct buffer_with_time_or_count typedef std::shared_ptr state_type; state_type state; - buffer_with_time_or_count_observer(dest_type d, buffer_with_time_or_count_values v, coordinator_type c) - : state(std::make_shared(buffer_with_time_or_count_subscriber_values(std::move(d), std::move(v), std::move(c)))) + buffer_with_time_or_count_observer(composite_subscription cs, dest_type d, buffer_with_time_or_count_values v, coordinator_type c) + : state(std::make_shared(buffer_with_time_or_count_subscriber_values(std::move(cs), std::move(d), std::move(v), std::move(c)))) { auto new_id = state->chunk_id; auto produce_time = state->worker.now() + state->period; auto localState = state; - state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ - produce_buffer(new_id, produce_time, localState); - }); - } - static void produce_buffer(int id, rxsc::scheduler::clock_type::time_point expected, state_type state) { - if (id != state->chunk_id) + auto disposer = [=](const rxsc::schedulable&){ + localState->cs.unsubscribe(); + localState->dest.unsubscribe(); + localState->worker.unsubscribe(); + }; + auto selectedDisposer = on_exception( + [&](){return localState->coordinator.act(disposer);}, + localState->dest); + if (selectedDisposer.empty()) { return; + } - state->dest.on_next(state->chunk); - state->chunk.resize(0); - auto new_id = ++state->chunk_id; - auto produce_time = expected + state->period; - auto localState = state; - state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ - produce_buffer(new_id, produce_time, localState); + localState->dest.add([=](){ + localState->worker.schedule(selectedDisposer.get()); + }); + localState->cs.add([=](){ + localState->worker.schedule(selectedDisposer.get()); }); + + // + // The scheduler is FIFO for any time T. Since the observer is scheduling + // on_next/on_error/oncompleted the timed schedule calls must be resheduled + // when they occur to ensure that production happens after on_next/on_error/oncompleted + // + + localState->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ + localState->worker.schedule(produce_buffer(new_id, produce_time, localState)); + }); + } + + static std::function produce_buffer(int id, rxsc::scheduler::clock_type::time_point expected, state_type state) { + auto produce = [id, expected, state](const rxsc::schedulable&) { + if (id != state->chunk_id) + return; + + state->dest.on_next(state->chunk); + state->chunk.resize(0); + auto new_id = ++state->chunk_id; + auto produce_time = expected + state->period; + state->worker.schedule(produce_time, [new_id, produce_time, state](const rxsc::schedulable&){ + state->worker.schedule(produce_buffer(new_id, produce_time, state)); + }); + }; + + auto selectedProduce = on_exception( + [&](){return state->coordinator.act(produce);}, + state->dest); + if (selectedProduce.empty()) { + return std::function(); + } + + return std::function(selectedProduce.get()); } void on_next(T v) const { - state->chunk.push_back(v); - if (int(state->chunk.size()) == state->count) { - produce_buffer(state->chunk_id, state->worker.now(), state); + auto localState = state; + auto work = [v, localState](const rxsc::schedulable& self){ + localState->chunk.push_back(v); + if (int(localState->chunk.size()) == localState->count) { + produce_buffer(localState->chunk_id, localState->worker.now(), localState)(self); + } + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; } + localState->worker.schedule(selectedWork.get()); } void on_error(std::exception_ptr e) const { - state->dest.on_error(e); + auto localState = state; + auto work = [e, localState](const rxsc::schedulable&){ + localState->dest.on_error(e); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; + } + localState->worker.schedule(selectedWork.get()); } void on_completed() const { - state->dest.on_next(state->chunk); - state->dest.on_completed(); + auto localState = state; + auto work = [localState](const rxsc::schedulable&){ + localState->dest.on_next(localState->chunk); + localState->dest.on_completed(); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; + } + localState->worker.schedule(selectedWork.get()); } static subscriber> make(dest_type d, buffer_with_time_or_count_values v) { - auto cs = d.get_subscription(); - auto coordinator = v.coordination.create_coordinator(cs); + auto cs = composite_subscription(); + auto coordinator = v.coordination.create_coordinator(); - return make_subscriber(std::move(cs), this_type(std::move(d), std::move(v), std::move(coordinator))); + return make_subscriber(cs, this_type(cs, std::move(d), std::move(v), std::move(coordinator))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp index 734520e..a64d83d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -51,14 +51,16 @@ struct window_with_time struct window_with_time_subscriber_values : public window_with_time_values { - window_with_time_subscriber_values(dest_type d, window_with_time_values v, coordinator_type c) + window_with_time_subscriber_values(composite_subscription cs, dest_type d, window_with_time_values v, coordinator_type c) : window_with_time_values(v) + , cs(std::move(cs)) , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) , expected(worker.now()) { } + composite_subscription cs; dest_type dest; coordinator_type coordinator; rxsc::worker worker; @@ -67,54 +69,129 @@ struct window_with_time }; std::shared_ptr state; - window_with_time_observer(dest_type d, window_with_time_values v, coordinator_type c) - : state(std::make_shared(window_with_time_subscriber_values(std::move(d), v, std::move(c)))) + window_with_time_observer(composite_subscription cs, dest_type d, window_with_time_values v, coordinator_type c) + : state(std::make_shared(window_with_time_subscriber_values(std::move(cs), std::move(d), v, std::move(c)))) { auto localState = state; + + auto disposer = [=](const rxsc::schedulable&){ + localState->cs.unsubscribe(); + localState->dest.unsubscribe(); + localState->worker.unsubscribe(); + }; + auto selectedDisposer = on_exception( + [&](){return localState->coordinator.act(disposer);}, + localState->dest); + if (selectedDisposer.empty()) { + return; + } + + localState->dest.add([=](){ + localState->worker.schedule(selectedDisposer.get()); + }); + localState->cs.add([=](){ + localState->worker.schedule(selectedDisposer.get()); + }); + + // + // The scheduler is FIFO for any time T. Since the observer is scheduling + // on_next/on_error/oncompleted the timed schedule calls must be resheduled + // when they occur to ensure that production happens after on_next/on_error/oncompleted + // + auto release_window = [localState](const rxsc::schedulable&) { - localState->subj[0].get_subscriber().on_completed(); - localState->subj.pop_front(); + localState->worker.schedule([localState](const rxsc::schedulable&) { + localState->subj[0].get_subscriber().on_completed(); + localState->subj.pop_front(); + }); }; - auto create_window = [localState, release_window](const rxsc::schedulable&) { + auto selectedRelease = on_exception( + [&](){return localState->coordinator.act(release_window);}, + localState->dest); + if (selectedRelease.empty()) { + return; + } + + auto create_window = [localState, selectedRelease](const rxsc::schedulable&) { localState->subj.push_back(rxcpp::subjects::subject()); localState->dest.on_next(localState->subj[localState->subj.size() - 1].get_observable().as_dynamic()); auto produce_at = localState->expected + localState->period; localState->expected += localState->skip; - localState->worker.schedule(produce_at, release_window); + localState->worker.schedule(produce_at, [localState, selectedRelease](const rxsc::schedulable&) { + localState->worker.schedule(selectedRelease.get()); + }); }; + auto selectedCreate = on_exception( + [&](){return localState->coordinator.act(create_window);}, + localState->dest); + if (selectedCreate.empty()) { + return; + } state->worker.schedule_periodically( state->expected, state->skip, - create_window); + [localState, selectedCreate](const rxsc::schedulable&) { + localState->worker.schedule(selectedCreate.get()); + }); } void on_next(T v) const { - for (auto s : state->subj) { - s.get_subscriber().on_next(v); + auto localState = state; + auto work = [v, localState](const rxsc::schedulable&){ + for (auto s : localState->subj) { + s.get_subscriber().on_next(v); + } + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; } + localState->worker.schedule(selectedWork.get()); } void on_error(std::exception_ptr e) const { - for (auto s : state->subj) { - s.get_subscriber().on_error(e); + auto localState = state; + auto work = [e, localState](const rxsc::schedulable&){ + for (auto s : localState->subj) { + s.get_subscriber().on_error(e); + } + localState->dest.on_error(e); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; } - state->dest.on_error(e); + localState->worker.schedule(selectedWork.get()); } void on_completed() const { - for (auto s : state->subj) { - s.get_subscriber().on_completed(); + auto localState = state; + auto work = [localState](const rxsc::schedulable&){ + for (auto s : localState->subj) { + s.get_subscriber().on_completed(); + } + localState->dest.on_completed(); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; } - state->dest.on_completed(); + localState->worker.schedule(selectedWork.get()); } static subscriber make(dest_type d, window_with_time_values v) { - auto cs = d.get_subscription(); - auto coordinator = v.coordination.create_coordinator(cs); + auto cs = composite_subscription(); + auto coordinator = v.coordination.create_coordinator(); - return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(v), std::move(coordinator)))); + return make_subscriber(cs, observer_type(this_type(cs, std::move(d), std::move(v), std::move(coordinator)))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp index fa50a57..5bb65ab 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp @@ -51,8 +51,9 @@ struct window_with_time_or_count struct window_with_time_or_count_subscriber_values : public window_with_time_or_count_values { - window_with_time_or_count_subscriber_values(dest_type d, window_with_time_or_count_values v, coordinator_type c) + window_with_time_or_count_subscriber_values(composite_subscription cs, dest_type d, window_with_time_or_count_values v, coordinator_type c) : window_with_time_or_count_values(std::move(v)) + , cs(std::move(cs)) , dest(std::move(d)) , coordinator(std::move(c)) , worker(std::move(coordinator.get_worker())) @@ -60,6 +61,7 @@ struct window_with_time_or_count , subj_id(0) { } + composite_subscription cs; dest_type dest; coordinator_type coordinator; rxsc::worker worker; @@ -70,56 +72,120 @@ struct window_with_time_or_count typedef std::shared_ptr state_type; state_type state; - window_with_time_or_count_observer(dest_type d, window_with_time_or_count_values v, coordinator_type c) - : state(std::make_shared(window_with_time_or_count_subscriber_values(std::move(d), std::move(v), std::move(c)))) + window_with_time_or_count_observer(composite_subscription cs, dest_type d, window_with_time_or_count_values v, coordinator_type c) + : state(std::make_shared(window_with_time_or_count_subscriber_values(std::move(cs), std::move(d), std::move(v), std::move(c)))) { - state->dest.on_next(state->subj.get_observable().as_dynamic()); auto new_id = state->subj_id; - auto produce_time = state->worker.now() + state->period; + auto produce_time = state->worker.now(); auto localState = state; - state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ - release_window(new_id, produce_time, localState); - }); - } - static void release_window(int id, rxsc::scheduler::clock_type::time_point expected, state_type state) { - if (id != state->subj_id) + auto disposer = [=](const rxsc::schedulable&){ + localState->cs.unsubscribe(); + localState->dest.unsubscribe(); + localState->worker.unsubscribe(); + }; + auto selectedDisposer = on_exception( + [&](){return localState->coordinator.act(disposer);}, + localState->dest); + if (selectedDisposer.empty()) { return; + } - state->subj.get_subscriber().on_completed(); - state->subj = rxcpp::subjects::subject(); - state->dest.on_next(state->subj.get_observable().as_dynamic()); - state->cursor = 0; - auto new_id = ++state->subj_id; - auto produce_time = expected + state->period; - auto localState = state; - state->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ - release_window(new_id, produce_time, localState); + localState->dest.add([=](){ + localState->worker.schedule(selectedDisposer.get()); + }); + localState->cs.add([=](){ + localState->worker.schedule(selectedDisposer.get()); }); + + // + // The scheduler is FIFO for any time T. Since the observer is scheduling + // on_next/on_error/oncompleted the timed schedule calls must be resheduled + // when they occur to ensure that production happens after on_next/on_error/oncompleted + // + + localState->worker.schedule(produce_time, [new_id, produce_time, localState](const rxsc::schedulable&){ + localState->worker.schedule(release_window(new_id, produce_time, localState)); + }); + } + + static std::function release_window(int id, rxsc::scheduler::clock_type::time_point expected, state_type state) { + auto release = [id, expected, state](const rxsc::schedulable&) { + if (id != state->subj_id) + return; + + state->subj.get_subscriber().on_completed(); + state->subj = rxcpp::subjects::subject(); + state->dest.on_next(state->subj.get_observable().as_dynamic()); + state->cursor = 0; + auto new_id = ++state->subj_id; + auto produce_time = expected + state->period; + state->worker.schedule(produce_time, [new_id, produce_time, state](const rxsc::schedulable&){ + state->worker.schedule(release_window(new_id, produce_time, state)); + }); + }; + auto selectedRelease = on_exception( + [&](){return state->coordinator.act(release);}, + state->dest); + if (selectedRelease.empty()) { + return std::function(); + } + + return std::function(selectedRelease.get()); } void on_next(T v) const { - state->subj.get_subscriber().on_next(v); - if (++state->cursor == state->count) { - release_window(state->subj_id, state->worker.now(), state); + auto localState = state; + auto work = [v, localState](const rxsc::schedulable&){ + localState->subj.get_subscriber().on_next(v); + if (++localState->cursor == localState->count) { + release_window(localState->subj_id, localState->worker.now(), localState); + } + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; } + localState->worker.schedule(selectedWork.get()); } void on_error(std::exception_ptr e) const { - state->subj.get_subscriber().on_error(e); - state->dest.on_error(e); + auto localState = state; + auto work = [e, localState](const rxsc::schedulable&){ + localState->subj.get_subscriber().on_error(e); + localState->dest.on_error(e); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; + } + localState->worker.schedule(selectedWork.get()); } void on_completed() const { - state->subj.get_subscriber().on_completed(); - state->dest.on_completed(); + auto localState = state; + auto work = [localState](const rxsc::schedulable&){ + localState->subj.get_subscriber().on_completed(); + localState->dest.on_completed(); + }; + auto selectedWork = on_exception( + [&](){return localState->coordinator.act(work);}, + localState->dest); + if (selectedWork.empty()) { + return; + } + localState->worker.schedule(selectedWork.get()); } static subscriber make(dest_type d, window_with_time_or_count_values v) { - auto cs = d.get_subscription(); - auto coordinator = v.coordination.create_coordinator(cs); + auto cs = composite_subscription(); + auto coordinator = v.coordination.create_coordinator(); - return make_subscriber(std::move(cs), observer_type(this_type(std::move(d), std::move(v), std::move(coordinator)))); + return make_subscriber(cs, observer_type(this_type(cs, std::move(d), std::move(v), std::move(coordinator)))); } }; diff --git a/Rx/v2/test/operators/buffer.cpp b/Rx/v2/test/operators/buffer.cpp index 5f97583..118709e 100644 --- a/Rx/v2/test/operators/buffer.cpp +++ b/Rx/v2/test/operators/buffer.cpp @@ -712,13 +712,13 @@ SCENARIO("buffer with time, overlapping intervals", "[buffer_with_time][operator THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(300, rxu::to_vector({ 2, 3, 4 })), - v_on.next(370, rxu::to_vector({ 4, 5, 6 })), - v_on.next(440, rxu::to_vector({ 6, 7, 8 })), - v_on.next(510, rxu::to_vector({ 8, 9 })), - v_on.next(580, std::vector()), - v_on.next(600, std::vector()), - v_on.completed(600) + v_on.next(301, rxu::to_vector({ 2, 3, 4 })), + v_on.next(371, rxu::to_vector({ 4, 5, 6 })), + v_on.next(441, rxu::to_vector({ 6, 7, 8 })), + v_on.next(511, rxu::to_vector({ 8, 9 })), + v_on.next(581, std::vector()), + v_on.next(601, std::vector()), + v_on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -769,11 +769,11 @@ SCENARIO("buffer with time, intervals with skips", "[buffer_with_time][operators THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(270, rxu::to_vector({ 2, 3 })), - v_on.next(370, rxu::to_vector({ 5, 6 })), - v_on.next(470, rxu::to_vector({ 8, 9 })), - v_on.next(570, std::vector()), - v_on.completed(600) + v_on.next(271, rxu::to_vector({ 2, 3 })), + v_on.next(371, rxu::to_vector({ 5, 6 })), + v_on.next(471, rxu::to_vector({ 8, 9 })), + v_on.next(571, std::vector()), + v_on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -826,12 +826,12 @@ SCENARIO("buffer with time, error", "[buffer_with_time][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(300, rxu::to_vector({ 2, 3, 4 })), - v_on.next(370, rxu::to_vector({ 4, 5, 6 })), - v_on.next(440, rxu::to_vector({ 6, 7, 8 })), - v_on.next(510, rxu::to_vector({ 8, 9 })), - v_on.next(580, std::vector()), - v_on.error(600, ex) + v_on.next(301, rxu::to_vector({ 2, 3, 4 })), + v_on.next(371, rxu::to_vector({ 4, 5, 6 })), + v_on.next(441, rxu::to_vector({ 6, 7, 8 })), + v_on.next(511, rxu::to_vector({ 8, 9 })), + v_on.next(581, std::vector()), + v_on.error(601, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -883,7 +883,7 @@ SCENARIO("buffer with time, disposed", "[buffer_with_time][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(300, rxu::to_vector({ 2, 3, 4 })), + v_on.next(301, rxu::to_vector({ 2, 3, 4 })), }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -891,7 +891,7 @@ SCENARIO("buffer with time, disposed", "[buffer_with_time][operators]"){ THEN("there was one subscription and one unsubscription to the xs"){ auto required = rxu::to_vector({ - on.subscribe(200, 370) + on.subscribe(200, 371) }); auto actual = xs.subscriptions(); REQUIRE(required == actual); @@ -934,11 +934,11 @@ SCENARIO("buffer with time, same", "[buffer_with_time][operators]"){ THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(300, rxu::to_vector({ 2, 3, 4 })), - v_on.next(400, rxu::to_vector({ 5, 6, 7 })), - v_on.next(500, rxu::to_vector({ 8, 9 })), - v_on.next(600, std::vector()), - v_on.completed(600) + v_on.next(301, rxu::to_vector({ 2, 3, 4 })), + v_on.next(401, rxu::to_vector({ 5, 6, 7 })), + v_on.next(501, rxu::to_vector({ 8, 9 })), + v_on.next(601, std::vector()), + v_on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -989,14 +989,14 @@ SCENARIO("buffer with time or count, basic", "[buffer_with_time_or_count][operat THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(240, rxu::to_vector({ 1, 2, 3 })), - v_on.next(310, rxu::to_vector({ 4 })), - v_on.next(370, rxu::to_vector({ 5, 6, 7 })), - v_on.next(440, rxu::to_vector({ 8 })), - v_on.next(510, rxu::to_vector({ 9 })), - v_on.next(580, std::vector()), - v_on.next(600, std::vector()), - v_on.completed(600) + v_on.next(241, rxu::to_vector({ 1, 2, 3 })), + v_on.next(312, rxu::to_vector({ 4 })), + v_on.next(371, rxu::to_vector({ 5, 6, 7 })), + v_on.next(442, rxu::to_vector({ 8 })), + v_on.next(512, rxu::to_vector({ 9 })), + v_on.next(582, std::vector()), + v_on.next(601, std::vector()), + v_on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -1049,13 +1049,13 @@ SCENARIO("buffer with time or count, error", "[buffer_with_time_or_count][operat THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(240, rxu::to_vector({ 1, 2, 3 })), - v_on.next(310, rxu::to_vector({ 4 })), - v_on.next(370, rxu::to_vector({ 5, 6, 7 })), - v_on.next(440, rxu::to_vector({ 8 })), - v_on.next(510, rxu::to_vector({ 9 })), - v_on.next(580, std::vector()), - v_on.error(600, ex) + v_on.next(241, rxu::to_vector({ 1, 2, 3 })), + v_on.next(312, rxu::to_vector({ 4 })), + v_on.next(371, rxu::to_vector({ 5, 6, 7 })), + v_on.next(442, rxu::to_vector({ 8 })), + v_on.next(512, rxu::to_vector({ 9 })), + v_on.next(582, std::vector()), + v_on.error(601, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -1102,14 +1102,14 @@ SCENARIO("buffer with time or count, dispose", "[buffer_with_time_or_count][oper // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); }, - 370 + 372 ); THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(240, rxu::to_vector({ 1, 2, 3 })), - v_on.next(310, rxu::to_vector({ 4 })), - v_on.next(370, rxu::to_vector({ 5, 6, 7 })), + v_on.next(241, rxu::to_vector({ 1, 2, 3 })), + v_on.next(312, rxu::to_vector({ 4 })), + v_on.next(371, rxu::to_vector({ 5, 6, 7 })), }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -1117,7 +1117,7 @@ SCENARIO("buffer with time or count, dispose", "[buffer_with_time_or_count][oper THEN("there was one subscription and one unsubscription to the xs"){ auto required = rxu::to_vector({ - on.subscribe(200, 370) + on.subscribe(200, 373) }); auto actual = xs.subscriptions(); REQUIRE(required == actual); @@ -1156,14 +1156,14 @@ SCENARIO("buffer with time or count, only time triggered", "[buffer_with_time_or THEN("the output contains groups of ints"){ auto required = rxu::to_vector({ - v_on.next(300, rxu::to_vector({ 1 })), - v_on.next(400, rxu::to_vector({ 2 })), - v_on.next(500, std::vector()), - v_on.next(600, rxu::to_vector({ 3 })), - v_on.next(700, rxu::to_vector({ 4, 5 })), - v_on.next(800, std::vector()), - v_on.next(850, std::vector()), - v_on.completed(850) + v_on.next(301, rxu::to_vector({ 1 })), + v_on.next(401, rxu::to_vector({ 2 })), + v_on.next(501, std::vector()), + v_on.next(601, rxu::to_vector({ 3 })), + v_on.next(701, rxu::to_vector({ 4, 5 })), + v_on.next(801, std::vector()), + v_on.next(851, std::vector()), + v_on.completed(851) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); diff --git a/Rx/v2/test/operators/window.cpp b/Rx/v2/test/operators/window.cpp index f7b0e78..35dc77d 100644 --- a/Rx/v2/test/operators/window.cpp +++ b/Rx/v2/test/operators/window.cpp @@ -343,23 +343,23 @@ SCENARIO("window with time, basic", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(270, 4), - on.next(270, 4), - on.next(320, 5), - on.next(320, 5), - on.next(360, 6), - on.next(360, 6), - on.next(390, 7), - on.next(390, 7), - on.next(410, 8), - on.next(410, 8), - on.next(460, 9), - on.next(460, 9), - on.next(470, 10), - on.next(470, 10), - on.completed(490) + on.next(211, 2), + on.next(241, 3), + on.next(271, 4), + on.next(271, 4), + on.next(321, 5), + on.next(321, 5), + on.next(361, 6), + on.next(361, 6), + on.next(391, 7), + on.next(391, 7), + on.next(411, 8), + on.next(411, 8), + on.next(461, 9), + on.next(461, 9), + on.next(471, 10), + on.next(471, 10), + on.completed(491) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -413,16 +413,16 @@ SCENARIO("window with time, basic same", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(270, 4), - on.next(320, 5), - on.next(360, 6), - on.next(390, 7), - on.next(410, 8), - on.next(460, 9), - on.next(470, 10), - on.completed(490) + on.next(211, 2), + on.next(241, 3), + on.next(271, 4), + on.next(321, 5), + on.next(361, 6), + on.next(391, 7), + on.next(411, 8), + on.next(461, 9), + on.next(471, 10), + on.completed(491) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -475,18 +475,18 @@ SCENARIO("window with time, basic 1", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(350, 6), - on.next(380, 7), - on.next(420, 8), - on.next(420, 8), - on.next(470, 9), - on.completed(600) + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(351, 6), + on.next(381, 7), + on.next(421, 8), + on.next(421, 8), + on.next(471, 9), + on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -539,13 +539,13 @@ SCENARIO("window with time, basic 2", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(320, 5), - on.next(350, 6), - on.next(420, 8), - on.next(470, 9), - on.completed(600) + on.next(211, 2), + on.next(241, 3), + on.next(321, 5), + on.next(351, 6), + on.next(421, 8), + on.next(471, 9), + on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -600,18 +600,18 @@ SCENARIO("window with time, error", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(350, 6), - on.next(380, 7), - on.next(420, 8), - on.next(420, 8), - on.next(470, 9), - on.error(600, ex) + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(351, 6), + on.next(381, 7), + on.next(421, 8), + on.next(421, 8), + on.next(471, 9), + on.error(601, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -665,13 +665,13 @@ SCENARIO("window with time, disposed", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(350, 6), + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(351, 6), }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -679,7 +679,7 @@ SCENARIO("window with time, disposed", "[window_with_time][operators]"){ THEN("there was one subscription and one unsubscription to the observable"){ auto required = rxu::to_vector({ - o_on.subscribe(200, 370) + o_on.subscribe(200, 371) }); auto actual = xs.subscriptions(); REQUIRE(required == actual); @@ -724,15 +724,15 @@ SCENARIO("window with time, basic same 1", "[window_with_time][operators]"){ THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(380, 7), - on.next(420, 8), - on.next(470, 9), - on.completed(600) + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(381, 7), + on.next(421, 8), + on.next(471, 9), + on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -785,16 +785,16 @@ SCENARIO("window with time or count, basic", "[window_with_time_or_count][operat THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(205, 1), - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(370, 7), - on.next(420, 8), - on.next(470, 9), - on.completed(600) + on.next(206, 1), + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(371, 7), + on.next(421, 8), + on.next(471, 9), + on.completed(601) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -849,16 +849,16 @@ SCENARIO("window with time or count, error", "[window_with_time_or_count][operat THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(205, 1), - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(370, 7), - on.next(420, 8), - on.next(470, 9), - on.error(600, ex) + on.next(206, 1), + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(371, 7), + on.next(421, 8), + on.next(471, 9), + on.error(601, ex) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -907,18 +907,18 @@ SCENARIO("window with time or count, disposed", "[window_with_time_or_count][ope // forget type to workaround lambda deduction bug on msvc 2013 .as_dynamic(); }, - 370 + 372 ); THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(205, 1), - on.next(210, 2), - on.next(240, 3), - on.next(280, 4), - on.next(320, 5), - on.next(350, 6), - on.next(370, 7) + on.next(206, 1), + on.next(211, 2), + on.next(241, 3), + on.next(281, 4), + on.next(321, 5), + on.next(351, 6), + on.next(371, 7) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); @@ -926,7 +926,7 @@ SCENARIO("window with time or count, disposed", "[window_with_time_or_count][ope THEN("there was one subscription and one unsubscription to the observable"){ auto required = rxu::to_vector({ - o_on.subscribe(200, 370) + o_on.subscribe(200, 373) }); auto actual = xs.subscriptions(); REQUIRE(required == actual); @@ -967,12 +967,12 @@ SCENARIO("window with time or count, only time triggered", "[window_with_time_or THEN("the output contains merged groups of ints"){ auto required = rxu::to_vector({ - on.next(205, 1), - on.next(305, 2), - on.next(505, 3), - on.next(605, 4), - on.next(610, 5), - on.completed(850) + on.next(206, 1), + on.next(306, 2), + on.next(506, 3), + on.next(606, 4), + on.next(611, 5), + on.completed(851) }); auto actual = res.get_observer().messages(); REQUIRE(required == actual); -- GitLab From 25dbb1162d5379fc86e85d9a3fae3e101ab67e8c Mon Sep 17 00:00:00 2001 From: Valery Kopylov Date: Thu, 16 Apr 2015 13:06:31 +0300 Subject: [PATCH 482/782] Implement thread local storage for iOS --- Rx/v2/src/rxcpp/rx-includes.hpp | 11 +++++ Rx/v2/src/rxcpp/rx-util.hpp | 43 ++++++++++++++++++- .../src/rxcpp/schedulers/rx-currentthread.hpp | 22 +++++++--- 3 files changed, 69 insertions(+), 7 deletions(-) diff --git a/Rx/v2/src/rxcpp/rx-includes.hpp b/Rx/v2/src/rxcpp/rx-includes.hpp index 1ac9de7..bfec60a 100644 --- a/Rx/v2/src/rxcpp/rx-includes.hpp +++ b/Rx/v2/src/rxcpp/rx-includes.hpp @@ -86,6 +86,13 @@ #define _VARIADIC_MAX 10 #endif +#if defined(__APPLE__) && defined(__MACH__) +#include +#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1) +#define RXCPP_ON_IOS +#endif +#endif + #pragma push_macro("min") #pragma push_macro("max") #undef min @@ -120,6 +127,10 @@ #include #include +#if defined(RXCPP_ON_IOS) +#include +#endif + #include "rx-util.hpp" #include "rx-predef.hpp" #include "rx-subscription.hpp" diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp index faedf0f..80014bd 100644 --- a/Rx/v2/src/rxcpp/rx-util.hpp +++ b/Rx/v2/src/rxcpp/rx-util.hpp @@ -7,7 +7,7 @@ #include "rx-includes.hpp" -#if !defined(RXCPP_THREAD_LOCAL) +#if !defined(RXCPP_ON_IOS) && !defined(RXCPP_THREAD_LOCAL) #if defined(_MSC_VER) #define RXCPP_THREAD_LOCAL __declspec(thread) #else @@ -634,6 +634,47 @@ private: } +#if !defined(RXCPP_THREAD_LOCAL) +template +class thread_local_storage +{ +private: + pthread_key_t key; + +public: + thread_local_storage() + { + pthread_key_create(&key, NULL); + } + + ~thread_local_storage() + { + pthread_key_delete(key); + } + + thread_local_storage& operator =(T* p) + { + pthread_setspecific(key, p); + return *this; + } + + bool operator !() + { + return pthread_getspecific(key) == NULL; + } + + T* operator ->() + { + return static_cast(pthread_getspecific(key)); + } + + T* get() + { + return static_cast(pthread_getspecific(key)); + } +}; +#endif + } namespace rxu=util; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp index 4f9f9b5..f9847f9 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-currentthread.hpp @@ -31,10 +31,17 @@ public: }; private: - static current_thread_queue_type*& current_thread_queue() { - static RXCPP_THREAD_LOCAL current_thread_queue_type* queue; +#if defined(RXCPP_THREAD_LOCAL) + static current_thread_queue_type*& current_thread_queue() { + static RXCPP_THREAD_LOCAL current_thread_queue_type* queue; + return queue; + } +#else + static rxu::thread_local_storage& current_thread_queue() { + static rxu::thread_local_storage queue; return queue; } +#endif public: @@ -60,7 +67,7 @@ public: return current_thread_queue()->queue.top(); } static void pop() { - auto state = current_thread_queue(); + auto& state = current_thread_queue(); if (!state) { abort(); } @@ -71,7 +78,7 @@ public: } } static void push(item_type item) { - auto state = current_thread_queue(); + auto& state = current_thread_queue(); if (!state) { abort(); } @@ -110,12 +117,15 @@ public: if (!current_thread_queue()) { abort(); } - destroy(current_thread_queue()); +#if defined(RXCPP_THREAD_LOCAL) + destroy(current_thread_queue()); +#else + destroy(current_thread_queue().get()); +#endif current_thread_queue() = nullptr; } }; - } struct current_thread : public scheduler_interface -- GitLab From 64c13fbd6cc2720f690e99a298857a7d7ab95d11 Mon Sep 17 00:00:00 2001 From: Shiva Shankar P Date: Mon, 20 Apr 2015 11:34:14 -0700 Subject: [PATCH 483/782] Fixing compilation error "class has virtual functions and accessible non-virtual destructor". The Fix is to add explicit virtual destructors where they're missing. --- Rx/v2/src/rxcpp/rx-observer.hpp | 1 + Rx/v2/src/rxcpp/rx-subscription.hpp | 1 + Rx/v2/src/rxcpp/rx-test.hpp | 1 + Rx/v2/src/rxcpp/schedulers/rx-test.hpp | 2 ++ 4 files changed, 5 insertions(+) diff --git a/Rx/v2/src/rxcpp/rx-observer.hpp b/Rx/v2/src/rxcpp/rx-observer.hpp index bbc72e0..a302c64 100644 --- a/Rx/v2/src/rxcpp/rx-observer.hpp +++ b/Rx/v2/src/rxcpp/rx-observer.hpp @@ -143,6 +143,7 @@ private: struct virtual_observer : public std::enable_shared_from_this { + virtual ~virtual_observer() {} virtual void on_next(T) const {}; virtual void on_error(std::exception_ptr) const {}; virtual void on_completed() const {}; diff --git a/Rx/v2/src/rxcpp/rx-subscription.hpp b/Rx/v2/src/rxcpp/rx-subscription.hpp index 77c9b20..5cfde65 100644 --- a/Rx/v2/src/rxcpp/rx-subscription.hpp +++ b/Rx/v2/src/rxcpp/rx-subscription.hpp @@ -75,6 +75,7 @@ class subscription : public subscription_base : issubscribed(initial) { } + virtual ~base_subscription_state() {} virtual void unsubscribe() { } std::atomic issubscribed; diff --git a/Rx/v2/src/rxcpp/rx-test.hpp b/Rx/v2/src/rxcpp/rx-test.hpp index 542c55b..0a248e9 100644 --- a/Rx/v2/src/rxcpp/rx-test.hpp +++ b/Rx/v2/src/rxcpp/rx-test.hpp @@ -18,6 +18,7 @@ struct test_subject_base typedef rxn::recorded::type> recorded_type; typedef std::shared_ptr> type; + virtual ~test_subject_base() {} virtual void on_subscribe(subscriber) const =0; virtual std::vector messages() const =0; virtual std::vector subscriptions() const =0; diff --git a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp index 20ad0bf..866ab31 100644 --- a/Rx/v2/src/rxcpp/schedulers/rx-test.hpp +++ b/Rx/v2/src/rxcpp/schedulers/rx-test.hpp @@ -309,6 +309,8 @@ public: } } + virtual ~hot_observable() {} + virtual void on_subscribe(observer_type o) const { observers.push_back(o); sv.push_back(rxn::subscription(sc->clock())); -- GitLab From 3c434df8c9b26d92f30a719ee6607b81e7734937 Mon Sep 17 00:00:00 2001 From: Shiva Shankar P Date: Mon, 20 Apr 2015 11:53:13 -0700 Subject: [PATCH 484/782] Fixing two issues of memory usage after free... 1) Using member variable instead of locally captured variable in lambda. Causes problem when the enclosing instance is destroyed. 2) Race condition that causes 'current_completer' to be reset and observer list to be emptied while another thread is iterating through the observers in on_next. --- Rx/v2/src/rxcpp/subjects/rx-subject.hpp | 8 +++++--- Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp | 2 +- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp index f94f8f9..9c4339c 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-subject.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-subject.hpp @@ -155,10 +155,12 @@ public: b->current_generation = b->state->generation; b->current_completer = b->completer; } - if (!b->current_completer || b->current_completer->observers.empty()) { + + auto current_completer = b->current_completer; + if (!current_completer || current_completer->observers.empty()) { return; } - for (auto& o : b->current_completer->observers) { + for (auto& o : current_completer->observers) { if (o.is_subscribed()) { o.on_next(v); } @@ -236,7 +238,7 @@ public: observable get_observable() const { auto keepAlive = s; return make_observable_dynamic([=](subscriber o){ - keepAlive.add(s.get_subscriber(), std::move(o)); + keepAlive.add(keepAlive.get_subscriber(), std::move(o)); }); } }; diff --git a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp index 9625a14..278209d 100644 --- a/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp +++ b/Rx/v2/src/rxcpp/subjects/rx-synchronize.hpp @@ -182,7 +182,7 @@ public: observable get_observable() const { auto keepAlive = s; return make_observable_dynamic([=](subscriber o){ - keepAlive.add(s.get_subscriber(), std::move(o)); + keepAlive.add(keepAlive.get_subscriber(), std::move(o)); }); } }; -- GitLab From d0b152042f0a0f5abba9a64c0e206b1cf9eef979 Mon Sep 17 00:00:00 2001 From: Valeriy Kopylov Date: Fri, 17 Apr 2015 12:36:40 +0300 Subject: [PATCH 485/782] Add Doxygen generator as a new task for make --- projects/CMake/CMakeLists.txt | 21 +- projects/doxygen/doxygen.conf.in | 2432 ++++++++++++++++++++++++++++++ 2 files changed, 2452 insertions(+), 1 deletion(-) create mode 100644 projects/doxygen/doxygen.conf.in diff --git a/projects/CMake/CMakeLists.txt b/projects/CMake/CMakeLists.txt index a0b1e66..54ea3bc 100644 --- a/projects/CMake/CMakeLists.txt +++ b/projects/CMake/CMakeLists.txt @@ -30,8 +30,11 @@ get_filename_component(RXCPP_DIR "${RXCPP_DIR}" PATH) MESSAGE( STATUS "RXCPP_DIR: " ${RXCPP_DIR} ) +set(IX_SRC_DIR ${RXCPP_DIR}/Ix/CPP/src) +set(RX_SRC_DIR ${RXCPP_DIR}/Rx/v2/src) + include_directories(SYSTEM ${RXCPP_DIR}/ext/catch/include) -include_directories(${RXCPP_DIR}/Ix/CPP/src ${RXCPP_DIR}/Rx/v2/src) +include_directories(IX_SRC_DIR RX_SRC_DIR) set(TEST_DIR ${RXCPP_DIR}/Rx/v2/test) @@ -120,3 +123,19 @@ set_tests_properties(ListTests PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ test c add_test(NAME ListTags COMMAND rxcppv2_test --list-tags) set_tests_properties(ListTags PROPERTIES PASS_REGULAR_EXPRESSION "[0-9]+ tags") + +# target to generate documentation with Doxygen +find_package(Doxygen) +if(DOXYGEN_FOUND) + set(DOXY_CONF ${RXCPP_DIR}/projects/doxygen/doxygen.conf) + set(DOXY_OUTPUT_DIR ${RXCPP_DIR}/projects/doxygen) + set(DOXY_INPUT_DIR "${IX_SRC_DIR} ${RX_SRC_DIR}") + + configure_file(${DOXY_CONF}.in ${DOXY_CONF}) + + add_custom_target(doc + COMMAND ${DOXYGEN_EXECUTABLE} ${DOXY_CONF} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Generating documentation with Doxygen" + VERBATIM) +endif() diff --git a/projects/doxygen/doxygen.conf.in b/projects/doxygen/doxygen.conf.in new file mode 100644 index 0000000..1ed8ca0 --- /dev/null +++ b/projects/doxygen/doxygen.conf.in @@ -0,0 +1,2432 @@ +# Doxyfile 1.8.9.1 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "RxCpp" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = "The Reactive Extensions for Native (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++." + +# With the PROJECT_LOGO tag one can specify a logo or an icon that is included +# in the documentation. The maximum height of the logo should not exceed 55 +# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy +# the logo to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = ${DOXY_OUTPUT_DIR} + +# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = NO + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new +# page for each member. If set to NO, the documentation of a member will be part +# of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, Javascript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: +# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: +# Fortran. In the later case the parser tries to guess whether the code is fixed +# or free formatted code, this is the default for Fortran type files), VHDL. For +# instance to make doxygen treat .inc files as Fortran files (default is PHP), +# and .f files as C (default is Fortran), use: inc=Fortran f=C. +# +# Note: For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by putting a % sign in front of the word or +# globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO, +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. If set to YES, local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO, only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO, these classes will be included in the various overviews. This option +# has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO, these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO, these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES, upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES, the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will +# append additional text to a page's title, such as Class Reference. If set to +# YES the compound reference will be hidden. +# The default value is: NO. + +HIDE_COMPOUND_REFERENCE= NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo +# list. This list is created by putting \todo commands in the documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test +# list. This list is created by putting \test commands in the documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES, the +# list will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. See also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO, doxygen will only warn about wrong or incomplete +# parameter documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. +# Note: If this tag is empty the current directory is searched. + +INPUT = ${DOXY_INPUT_DIR} + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank the +# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, +# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, +# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, +# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, +# *.qsf, *.as and *.js. + +FILE_PATTERNS = *.c \ + *.cc \ + *.cxx \ + *.cpp \ + *.c++ \ + *.java \ + *.ii \ + *.ixx \ + *.ipp \ + *.i++ \ + *.inl \ + *.idl \ + *.ddl \ + *.odl \ + *.h \ + *.hh \ + *.hxx \ + *.hpp \ + *.h++ \ + *.cs \ + *.d \ + *.php \ + *.php4 \ + *.php5 \ + *.phtml \ + *.inc \ + *.m \ + *.markdown \ + *.md \ + *.mm \ + *.dox \ + *.py \ + *.f90 \ + *.f \ + *.for \ + *.tcl \ + *.vhd \ + *.vhdl \ + *.ucf \ + *.qsf \ + *.as \ + *.js + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the +# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the +# cost of reduced performance. This can be particularly helpful with template +# rich C++ code for which doxygen's built-in parser lacks the necessary type +# information. +# Note: The availability of this option depends on whether or not doxygen was +# compiled with the --with-libclang option. +# The default value is: NO. + +CLANG_ASSISTED_PARSING = NO + +# If clang assisted parsing is enabled you can provide the compiler with command +# line options that you would normally use when invoking the compiler. Note that +# the include paths will already be set by doxygen for the files and directories +# specified with INPUT and INCLUDE_PATH. +# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. + +CLANG_OPTIONS = + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# cascading style sheets that are included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefore more robust against future updates. +# Doxygen will copy the style sheet files to the output directory. +# Note: The order of the extra style sheet files is of importance (e.g. the last +# style sheet in the list overrules the setting of the previous ones in the +# list). For an example see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the style sheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler (hhc.exe). If non-empty, +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated +# (YES) or that it should be included in the master .chm file (NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated +# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side Javascript for the rendering +# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /

Reactive Extensions is available for different platforms such as C++, Javascript, .NET Framework 3.5, 4.0, 4.5, Silverlight 3 and 4, as well as Windows Phone 7 & 8. You can download the libraries, as well as learn about their prerequisites at the Rx MSDN Developer Center.

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\^{? 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